@omnia/fx 8.0.111-vnext → 8.0.113-vnext

package/internal-do-not-import-from-here/ux/properties/builtins/usertype/UserTypeEditor.d.ts

@@ -0,0 +1,129 @@
+import { IPropertyEditorRenderer, PropertyValueType, UserTypePropertyDefinition, UserTypePropertyValue } from "@omnia/fx-models";
+export type UserTypeEditorProps = IPropertyEditorRenderer<UserTypePropertyDefinition> & {
+    "v-model": PropertyValueType<UserTypePropertyDefinition>;
+};
+declare const _default: {
+    new (...args: any[]): {
+        $: import("vue").ComponentInternalInstance;
+        $data: {};
+        $props: {
+            style?: unknown;
+            class?: unknown;
+            key?: string | number | symbol;
+            readonly disabled?: boolean;
+            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)[];
+            readonly "v-model"?: UserTypePropertyValue;
+            readonly modelValue?: UserTypePropertyValue;
+            readonly displaySettings?: import("@omnia/fx-models").UserTypeDisplaySettings;
+            readonly setupSettings?: never;
+            readonly editorSettings?: import("@omnia/fx-models").UserTypeEditorSettings;
+        };
+        $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<Readonly<import("vue").ExtractPropTypes<{
+            modelValue: import("vue").Prop<UserTypePropertyValue, UserTypePropertyValue>;
+            editorSettings: import("vue").Prop<import("@omnia/fx-models").UserTypeEditorSettings, import("@omnia/fx-models").UserTypeEditorSettings>;
+            displaySettings: import("vue").Prop<import("@omnia/fx-models").UserTypeDisplaySettings, import("@omnia/fx-models").UserTypeDisplaySettings>;
+            setupSettings?: import("vue").Prop<never, never>;
+            disabled?: import("vue").Prop<boolean, boolean>;
+            "v-model": import("vue").Prop<UserTypePropertyValue, UserTypePropertyValue>;
+        }>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}>, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}>, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof import("vue").nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: import("vue").WatchOptions<boolean>): import("vue").WatchStopHandle;
+    } & Readonly<import("vue").ExtractPropTypes<{
+        modelValue: import("vue").Prop<UserTypePropertyValue, UserTypePropertyValue>;
+        editorSettings: import("vue").Prop<import("@omnia/fx-models").UserTypeEditorSettings, import("@omnia/fx-models").UserTypeEditorSettings>;
+        displaySettings: import("vue").Prop<import("@omnia/fx-models").UserTypeDisplaySettings, import("@omnia/fx-models").UserTypeDisplaySettings>;
+        setupSettings?: import("vue").Prop<never, never>;
+        disabled?: import("vue").Prop<boolean, boolean>;
+        "v-model": import("vue").Prop<UserTypePropertyValue, UserTypePropertyValue>;
+    }>> & import("vue").ShallowUnwrapRef<{}> & {} & import("vue").ComponentCustomProperties & {};
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+    modelValue: import("vue").Prop<UserTypePropertyValue, UserTypePropertyValue>;
+    editorSettings: import("vue").Prop<import("@omnia/fx-models").UserTypeEditorSettings, import("@omnia/fx-models").UserTypeEditorSettings>;
+    displaySettings: import("vue").Prop<import("@omnia/fx-models").UserTypeDisplaySettings, import("@omnia/fx-models").UserTypeDisplaySettings>;
+    setupSettings?: import("vue").Prop<never, never>;
+    disabled?: import("vue").Prop<boolean, boolean>;
+    "v-model": import("vue").Prop<UserTypePropertyValue, UserTypePropertyValue>;
+}>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+    propsDefinition: Omit<Readonly<{} & {
+        disabled?: boolean;
+        "v-model"?: UserTypePropertyValue;
+        modelValue?: UserTypePropertyValue;
+        displaySettings?: import("@omnia/fx-models").UserTypeDisplaySettings;
+        setupSettings?: never;
+        editorSettings?: import("@omnia/fx-models").UserTypeEditorSettings;
+    }>, never>;
+};
+export default _default;

package/internal-do-not-import-from-here/ux/properties/builtins/usertype/UserTypePropertyDefinition.d.ts

@@ -0,0 +1 @@
+export {};

package/internal-do-not-import-from-here/ux/properties/models/PropertyApi.d.ts

@@ -1,9 +1,10 @@
-import { EnterprisePropertyDefinition, IExtendApiManifestWithConfiguration, PropertyDataSourceId, PropertyDefinition } from "@omnia/fx-models";
+import { EnterprisePropertyDefinition, IExtendApiManifestWithConfiguration, PropertyBindingProviderId, PropertyDataSourceId, PropertyDefinition, PropertyValuePrimitiveConverter } from "@omnia/fx-models";
 import { GuidValue } from "../../../shared/models";
 import { VueComponentBase } from "../../VueComponentBase";
 import { PropertyDefinitionId, PropertySettings } from "./Properties";
 import { IPropertyDataSourceRegistrationApi } from "./DataSource";
 import { DataSourcePropertyDefintionHandlerId } from "@omnia/fx/services";
+import { IPropertyBindingProviderRegistrationApi } from "./PropertyBindingProvider";
 export type PropertyRegistrationId = GuidValue;
 export interface PropertyRegistration {
     id: PropertyRegistrationId;
@@ -21,7 +22,7 @@ export interface IPropertyRegistrationApi {
     register(registration: PropertyRegistration): void;
 }
 export interface IPropertyDefinitionRegistrationApi {
-    register<TPropertyDef extends PropertyDefinition<any, any, any>>(propertyDefinitionConstructor: new () => TPropertyDef, readRenderComponentManifestId: GuidValue, editRendererComponentManifestId: GuidValue, configurationRendererComponentManifestId?: GuidValue): any;
+    register<TPropertyDef extends PropertyDefinition<any, any, any>>(propertyDefinitionConstructor: new () => TPropertyDef, readRenderComponentManifestId: GuidValue, editRendererComponentManifestId: GuidValue, propertyValuePrimitiveConverterCtor: new () => PropertyValuePrimitiveConverter, configurationRendererComponentManifestId?: GuidValue): any;
     getPropertyDefinitionsByIds(propertyDefinitionIds: Array<PropertyDefinitionId>): Promise<Array<ResolvedPropertyDefinition>>;
     getPropertyDefinitions(): Promise<Array<ResolvedPropertyDefinition>>;
 }
@@ -31,6 +32,7 @@ export interface ResolvedPropertyDefinition {
     propertyDefinition: new () => PropertyDefinition<any, any, any>;
     readRenderComponentManifestId: GuidValue;
     editRendererComponentManifestId: GuidValue;
+    propertyValuePrimitiveConverterCtor: new () => PropertyValuePrimitiveConverter;
     configurationRendererComponentManifestId?: GuidValue;
 }
 declare module "@omnia/fx-models" {
@@ -40,6 +42,9 @@ declare module "@omnia/fx-models" {
             dataSources: {
                 registrations: Promise<IPropertyDataSourceRegistrationApi>;
             };
+            bindingProviders: {
+                registrations: Promise<IPropertyBindingProviderRegistrationApi>;
+            };
         };
     }
     interface IOmniaUxExtendApiManifest {
@@ -58,6 +63,9 @@ declare module "@omnia/fx-models" {
                     dataSourcePropertyDefinitionHandlerId: DataSourcePropertyDefintionHandlerId;
                 }>;
             };
+            bindingProviders: {
+                registrations: IExtendApiManifestWithConfiguration<PropertyBindingProviderId>;
+            };
         };
     }
 }

package/internal-do-not-import-from-here/ux/properties/models/PropertyBindingProvider.d.ts

@@ -0,0 +1,8 @@
+import { IPropertyBindingProvider, Guid } from "@omnia/fx-models";
+export interface IPropertyBindingProviderRegistrationApi extends IRegisteredPropertyBindingProviderApi {
+    registerProvider<TPropertyBindingProvider extends IPropertyBindingProvider>(registration: new () => TPropertyBindingProvider): void;
+}
+export interface IRegisteredPropertyBindingProviderApi {
+    getProviders(): Promise<(new () => IPropertyBindingProvider)[]>;
+    getProvider(providerId: Guid): Promise<(new () => IPropertyBindingProvider)>;
+}

package/internal-do-not-import-from-here/ux/properties/models/PropertyInput.d.ts

@@ -1,4 +1,5 @@
 import { DataSourceProperty, DataSourcePropertyCategory } from "@omnia/fx-models";
+import { IDataSourcePropertyCreator } from "../../../services";
 export interface IPropertyInput {
     valueBind: PropertyRegistration;
     onValueChanged?: (model: PropertyRegistration) => void;
@@ -9,6 +10,7 @@ export interface IPropertyInput {
     multiple?: boolean;
     propertyRegistrations: Array<PropertyRegistration>;
     loadingProperties: boolean;
+    propertyCreator: IDataSourcePropertyCreator;
 }
 export declare class PropertyRegistration {
     dataSourcePropertyBinding: DataSourceProperty;

package/internal-do-not-import-from-here/ux/properties/models/PropertyPicker.d.ts

@@ -1,4 +1,4 @@
-import { DataSourceProperty, PropertyConfiguration, PropertyDataSourceId, PropertyDefinition } from "@omnia/fx-models";
+import { DataSourceProperty, GuidValue, PropertyConfiguration, PropertyDataSourceId, PropertyDefinition } from "@omnia/fx-models";
 import { DataSourcePropertyDefintionHandlerId } from "../../../services";
 export interface IDataSourcePropertySelection {
     dataSourceProperty: DataSourceProperty;
@@ -7,10 +7,13 @@ export interface IDataSourcePropertySelection {
 }
 export interface IPropertyPicker {
     selectableDataSources: Array<PropertyDataSourceId>;
-    onDataSourcePropertySelected: (selection: IDataSourcePropertySelection) => Promise<void>;
+    onDataSourcePropertySelected: (selection: IDataSourcePropertySelection, allowEdit: boolean) => Promise<void>;
     filled?: boolean;
     disabled?: boolean;
     dark?: boolean;
     hideDetails?: boolean;
     multiple?: boolean;
+    hideConfiguration?: boolean;
+    selectionProperty?: IDataSourcePropertySelection;
+    selectablePropertyConverters?: Array<GuidValue>;
 }

package/internal-do-not-import-from-here/ux/properties/models/PropertySettingsLock.d.ts

@@ -0,0 +1,25 @@
+import { IPropertyConfigurationRenderer, PropertyDefinition, PropertyDisplaySettingsBase, PropertyValue } from "@omnia/fx-models";
+export declare enum PropertyLockStatus {
+    open = 1,
+    locked = 2,
+    rollback = 3
+}
+export declare class PropertyLockStatusHelper {
+    static get(status: PropertyLockStatus | undefined, defaultValue?: PropertyLockStatus): PropertyLockStatus;
+}
+export type PropertyLockStatusType<T> = T extends object ? {
+    [K in keyof T]?: PropertyLockStatusType<T[K]>;
+} : PropertyLockStatus;
+export declare function createDefaultLockStatus<T extends object>(type: T): PropertyLockStatusType<T>;
+export declare function removeLockStatus<T extends object>(instance: T, value: PropertyLockStatus): Partial<T>;
+export declare function keepOnlyLockStatus<T extends object>(instance: T, value: PropertyLockStatus): Partial<T>;
+export declare function updateWithLocked<A extends {
+    [key: string]: any;
+}, B extends {
+    [key: string]: any;
+}>(toUpdate: A, lockedProperties: B): A;
+export type LockStatusExcludeChildren<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>> & Record<K, PropertyLockStatus>;
+export type LockingPropertyDisplaySettings = {
+    locks?: PropertyLockStatusType<LockStatusExcludeChildren<Omit<LockingPropertyDisplaySettings, "locks">, "label">>;
+} & PropertyDisplaySettingsBase;
+export declare function getAllowRollback(props: IPropertyConfigurationRenderer<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, any>>, value: any, defaultValue: any): boolean;

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

@@ -1,4 +1,6 @@
 export * from "./DataSource";
 export * from "./PropertyApi";
 export * from "./PropertyPicker";
+export * from "./PropertySettingsLock";
+export * from "./PropertyBindingProvider";
 export * from "./Properties";

package/internal-do-not-import-from-here/ux/properties/property-configuration/LabelOptionsRenderer.d.ts

@@ -1,4 +1,5 @@
-import { PropertyDefinition, PropertyValue, LockingPropertyDisplaySettings, PropertyConfiguration } from "@omnia/fx-models";
+import { PropertyDefinition, PropertyValue, PropertyConfiguration } from "@omnia/fx-models";
+import { LockingPropertyDisplaySettings } from "@omnia/fx/ux";
 declare const _default: {
     new (...args: any[]): {
         $: import("vue").ComponentInternalInstance;
@@ -48,10 +49,12 @@ declare const _default: {
             }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                 [key: string]: any;
             }>) => void)[];
-            readonly modelValue?: PropertyConfiguration<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, any, import("@omnia/fx-models").PropertySetupBase>>;
             readonly "v-model"?: PropertyConfiguration<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, any, import("@omnia/fx-models").PropertySetupBase>>;
+            readonly modelValue?: PropertyConfiguration<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, any, import("@omnia/fx-models").PropertySetupBase>>;
             readonly onConfigurationValid?: (validConfig?: PropertyConfiguration<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, any, import("@omnia/fx-models").PropertySetupBase>>) => void;
             readonly showLockConfiguration?: boolean;
+            readonly renderEditSettings?: boolean;
+            readonly defaultConfiguration?: PropertyConfiguration<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, any, import("@omnia/fx-models").PropertySetupBase>>;
         };
         $attrs: {
             [x: string]: unknown;
@@ -70,6 +73,8 @@ declare const _default: {
             modelValue: import("vue").Prop<PropertyConfiguration<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, any, import("@omnia/fx-models").PropertySetupBase>>, PropertyConfiguration<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, any, import("@omnia/fx-models").PropertySetupBase>>>;
             onConfigurationValid: import("vue").Prop<(validConfig?: PropertyConfiguration<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, any, import("@omnia/fx-models").PropertySetupBase>>) => void, (validConfig?: PropertyConfiguration<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, any, import("@omnia/fx-models").PropertySetupBase>>) => void>;
             showLockConfiguration?: import("vue").Prop<boolean, boolean>;
+            renderEditSettings?: import("vue").Prop<boolean, boolean>;
+            defaultConfiguration?: import("vue").Prop<PropertyConfiguration<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, any, import("@omnia/fx-models").PropertySetupBase>>, PropertyConfiguration<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, any, import("@omnia/fx-models").PropertySetupBase>>>;
             "v-model": import("vue").Prop<PropertyConfiguration<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, any, import("@omnia/fx-models").PropertySetupBase>>, PropertyConfiguration<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, any, import("@omnia/fx-models").PropertySetupBase>>>;
         }>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}> & {
             beforeCreate?: (() => void) | (() => void)[];
@@ -95,6 +100,8 @@ declare const _default: {
         modelValue: import("vue").Prop<PropertyConfiguration<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, any, import("@omnia/fx-models").PropertySetupBase>>, PropertyConfiguration<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, any, import("@omnia/fx-models").PropertySetupBase>>>;
         onConfigurationValid: import("vue").Prop<(validConfig?: PropertyConfiguration<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, any, import("@omnia/fx-models").PropertySetupBase>>) => void, (validConfig?: PropertyConfiguration<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, any, import("@omnia/fx-models").PropertySetupBase>>) => void>;
         showLockConfiguration?: import("vue").Prop<boolean, boolean>;
+        renderEditSettings?: import("vue").Prop<boolean, boolean>;
+        defaultConfiguration?: import("vue").Prop<PropertyConfiguration<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, any, import("@omnia/fx-models").PropertySetupBase>>, PropertyConfiguration<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, any, import("@omnia/fx-models").PropertySetupBase>>>;
         "v-model": import("vue").Prop<PropertyConfiguration<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, any, import("@omnia/fx-models").PropertySetupBase>>, PropertyConfiguration<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, any, import("@omnia/fx-models").PropertySetupBase>>>;
     }>> & import("vue").ShallowUnwrapRef<{}> & {} & import("vue").ComponentCustomProperties & {};
     __isFragment?: never;
@@ -104,13 +111,17 @@ declare const _default: {
     modelValue: import("vue").Prop<PropertyConfiguration<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, any, import("@omnia/fx-models").PropertySetupBase>>, PropertyConfiguration<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, any, import("@omnia/fx-models").PropertySetupBase>>>;
     onConfigurationValid: import("vue").Prop<(validConfig?: PropertyConfiguration<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, any, import("@omnia/fx-models").PropertySetupBase>>) => void, (validConfig?: PropertyConfiguration<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, any, import("@omnia/fx-models").PropertySetupBase>>) => void>;
     showLockConfiguration?: import("vue").Prop<boolean, boolean>;
+    renderEditSettings?: import("vue").Prop<boolean, boolean>;
+    defaultConfiguration?: import("vue").Prop<PropertyConfiguration<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, any, import("@omnia/fx-models").PropertySetupBase>>, PropertyConfiguration<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, any, import("@omnia/fx-models").PropertySetupBase>>>;
     "v-model": import("vue").Prop<PropertyConfiguration<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, any, import("@omnia/fx-models").PropertySetupBase>>, PropertyConfiguration<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, any, import("@omnia/fx-models").PropertySetupBase>>>;
 }>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
     propsDefinition: Omit<Readonly<{} & {
-        modelValue?: PropertyConfiguration<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, any, import("@omnia/fx-models").PropertySetupBase>>;
         "v-model"?: PropertyConfiguration<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, any, import("@omnia/fx-models").PropertySetupBase>>;
+        modelValue?: PropertyConfiguration<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, any, import("@omnia/fx-models").PropertySetupBase>>;
         onConfigurationValid?: (validConfig?: PropertyConfiguration<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, any, import("@omnia/fx-models").PropertySetupBase>>) => void;
         showLockConfiguration?: boolean;
+        renderEditSettings?: boolean;
+        defaultConfiguration?: PropertyConfiguration<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, any, import("@omnia/fx-models").PropertySetupBase>>;
     }>, never>;
 };
 export default _default;

package/internal-do-not-import-from-here/ux/properties/property-configuration/PropertyConfiguration.d.ts

@@ -1,4 +1,5 @@
-import { PropertyDefinition, PropertyValue, LockingPropertyDisplaySettings, PropertyConfiguration } from "@omnia/fx-models";
+import { PropertyDefinition, PropertyValue, PropertyEditorSettingsBase, PropertyConfiguration } from "@omnia/fx-models";
+import { LockingPropertyDisplaySettings } from "@omnia/fx/ux";
 declare const _default: {
     new (...args: any[]): {
         $: import("vue").ComponentInternalInstance;
@@ -48,10 +49,12 @@ declare const _default: {
             }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                 [key: string]: any;
             }>) => void)[];
+            readonly "v-model"?: PropertyConfiguration<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, PropertyEditorSettingsBase, import("@omnia/fx-models").PropertySetupBase>>;
             readonly modelValue?: PropertyConfiguration<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, any, import("@omnia/fx-models").PropertySetupBase>>;
-            readonly "v-model"?: PropertyConfiguration<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, any, import("@omnia/fx-models").PropertySetupBase>>;
             readonly onConfigurationValid?: (validConfig?: PropertyConfiguration<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, any, import("@omnia/fx-models").PropertySetupBase>>) => void;
             readonly showLockConfiguration?: boolean;
+            readonly renderEditSettings?: boolean;
+            readonly defaultConfiguration?: PropertyConfiguration<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, any, import("@omnia/fx-models").PropertySetupBase>>;
         };
         $attrs: {
             [x: string]: unknown;
@@ -70,7 +73,9 @@ declare const _default: {
             modelValue: import("vue").Prop<PropertyConfiguration<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, any, import("@omnia/fx-models").PropertySetupBase>>, PropertyConfiguration<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, any, import("@omnia/fx-models").PropertySetupBase>>>;
             onConfigurationValid: import("vue").Prop<(validConfig?: PropertyConfiguration<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, any, import("@omnia/fx-models").PropertySetupBase>>) => void, (validConfig?: PropertyConfiguration<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, any, import("@omnia/fx-models").PropertySetupBase>>) => void>;
             showLockConfiguration?: import("vue").Prop<boolean, boolean>;
-            "v-model": import("vue").Prop<PropertyConfiguration<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, any, import("@omnia/fx-models").PropertySetupBase>>, PropertyConfiguration<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, any, import("@omnia/fx-models").PropertySetupBase>>>;
+            renderEditSettings?: import("vue").Prop<boolean, boolean>;
+            defaultConfiguration?: import("vue").Prop<PropertyConfiguration<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, any, import("@omnia/fx-models").PropertySetupBase>>, PropertyConfiguration<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, any, import("@omnia/fx-models").PropertySetupBase>>>;
+            "v-model": import("vue").Prop<PropertyConfiguration<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, PropertyEditorSettingsBase, import("@omnia/fx-models").PropertySetupBase>>, PropertyConfiguration<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, PropertyEditorSettingsBase, import("@omnia/fx-models").PropertySetupBase>>>;
         }>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}> & {
             beforeCreate?: (() => void) | (() => void)[];
             created?: (() => void) | (() => void)[];
@@ -95,7 +100,9 @@ declare const _default: {
         modelValue: import("vue").Prop<PropertyConfiguration<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, any, import("@omnia/fx-models").PropertySetupBase>>, PropertyConfiguration<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, any, import("@omnia/fx-models").PropertySetupBase>>>;
         onConfigurationValid: import("vue").Prop<(validConfig?: PropertyConfiguration<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, any, import("@omnia/fx-models").PropertySetupBase>>) => void, (validConfig?: PropertyConfiguration<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, any, import("@omnia/fx-models").PropertySetupBase>>) => void>;
         showLockConfiguration?: import("vue").Prop<boolean, boolean>;
-        "v-model": import("vue").Prop<PropertyConfiguration<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, any, import("@omnia/fx-models").PropertySetupBase>>, PropertyConfiguration<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, any, import("@omnia/fx-models").PropertySetupBase>>>;
+        renderEditSettings?: import("vue").Prop<boolean, boolean>;
+        defaultConfiguration?: import("vue").Prop<PropertyConfiguration<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, any, import("@omnia/fx-models").PropertySetupBase>>, PropertyConfiguration<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, any, import("@omnia/fx-models").PropertySetupBase>>>;
+        "v-model": import("vue").Prop<PropertyConfiguration<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, PropertyEditorSettingsBase, import("@omnia/fx-models").PropertySetupBase>>, PropertyConfiguration<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, PropertyEditorSettingsBase, import("@omnia/fx-models").PropertySetupBase>>>;
     }>> & import("vue").ShallowUnwrapRef<{}> & {} & import("vue").ComponentCustomProperties & {};
     __isFragment?: never;
     __isTeleport?: never;
@@ -104,13 +111,17 @@ declare const _default: {
     modelValue: import("vue").Prop<PropertyConfiguration<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, any, import("@omnia/fx-models").PropertySetupBase>>, PropertyConfiguration<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, any, import("@omnia/fx-models").PropertySetupBase>>>;
     onConfigurationValid: import("vue").Prop<(validConfig?: PropertyConfiguration<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, any, import("@omnia/fx-models").PropertySetupBase>>) => void, (validConfig?: PropertyConfiguration<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, any, import("@omnia/fx-models").PropertySetupBase>>) => void>;
     showLockConfiguration?: import("vue").Prop<boolean, boolean>;
-    "v-model": import("vue").Prop<PropertyConfiguration<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, any, import("@omnia/fx-models").PropertySetupBase>>, PropertyConfiguration<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, any, import("@omnia/fx-models").PropertySetupBase>>>;
+    renderEditSettings?: import("vue").Prop<boolean, boolean>;
+    defaultConfiguration?: import("vue").Prop<PropertyConfiguration<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, any, import("@omnia/fx-models").PropertySetupBase>>, PropertyConfiguration<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, any, import("@omnia/fx-models").PropertySetupBase>>>;
+    "v-model": import("vue").Prop<PropertyConfiguration<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, PropertyEditorSettingsBase, import("@omnia/fx-models").PropertySetupBase>>, PropertyConfiguration<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, PropertyEditorSettingsBase, import("@omnia/fx-models").PropertySetupBase>>>;
 }>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
     propsDefinition: Omit<Readonly<{} & {
+        "v-model"?: PropertyConfiguration<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, PropertyEditorSettingsBase, import("@omnia/fx-models").PropertySetupBase>>;
         modelValue?: PropertyConfiguration<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, any, import("@omnia/fx-models").PropertySetupBase>>;
-        "v-model"?: PropertyConfiguration<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, any, import("@omnia/fx-models").PropertySetupBase>>;
         onConfigurationValid?: (validConfig?: PropertyConfiguration<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, any, import("@omnia/fx-models").PropertySetupBase>>) => void;
         showLockConfiguration?: boolean;
+        renderEditSettings?: boolean;
+        defaultConfiguration?: PropertyConfiguration<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, any, import("@omnia/fx-models").PropertySetupBase>>;
     }>, never>;
 };
 export default _default;

package/internal-do-not-import-from-here/ux/properties/property-configuration/PropertyConfigurationV2.d.ts

@@ -70,6 +70,7 @@ declare const _default: {
                 }>;
             };
             key?: string | number | symbol;
+            readonly disabled?: boolean;
             ref?: import("vue").VNodeRef;
             ref_for?: boolean;
             ref_key?: string;
@@ -111,8 +112,6 @@ declare const _default: {
             }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                 [key: string]: any;
             }>) => void)[];
-            readonly disabled?: boolean;
-            readonly modelValue?: ModelValueType;
             readonly "v-slots"?: {
                 default?: import("../../DefineVueTypings").Slot<any[]>;
             } & {
@@ -121,6 +120,7 @@ declare const _default: {
                 appendEditorSettings?(value: PropertyEditorSettingsBase, disabled: boolean): VNodeChild;
             };
             readonly "v-model"?: ModelValueType;
+            readonly modelValue?: ModelValueType;
             readonly "onUpdate:modelValue"?: (value: ModelValueType) => any;
             readonly hideDisplaySettings?: boolean;
             readonly "hide-display-settings"?: boolean;
@@ -501,7 +501,6 @@ declare const _default: {
             }>;
         };
         disabled?: boolean;
-        modelValue?: ModelValueType;
         "v-slots"?: {
             default?: import("../../DefineVueTypings").Slot<any[]>;
         } & {
@@ -510,6 +509,7 @@ declare const _default: {
             appendEditorSettings?(value: PropertyEditorSettingsBase, disabled: boolean): VNodeChild;
         };
         "v-model"?: ModelValueType;
+        modelValue?: ModelValueType;
         "onUpdate:modelValue"?: (value: ModelValueType) => any;
         hideDisplaySettings?: boolean;
         "hide-display-settings"?: boolean;

package/internal-do-not-import-from-here/ux/properties/property-configuration/PropertyLocking.d.ts

@@ -1,4 +1,4 @@
-import { PropertyLockStatus } from "@omnia/fx/models";
+import { PropertyLockStatus } from "@omnia/fx/ux";
 declare const _default: {
     new (...args: any[]): {
         $: import("vue").ComponentInternalInstance;
@@ -53,8 +53,10 @@ declare const _default: {
             };
             readonly onValueChanged?: Function;
             readonly renderBody?: () => JSX.Element[];
+            readonly rollback?: Function;
             readonly showLockConfiguration?: boolean;
             readonly lockingStatus?: PropertyLockStatus;
+            readonly allowRollback?: unknown;
         };
         $attrs: {
             [x: string]: unknown;
@@ -72,6 +74,8 @@ declare const _default: {
         $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
             lockingStatus: import("vue").Prop<PropertyLockStatus, PropertyLockStatus>;
             onValueChanged: import("vue").Prop<Function, Function>;
+            allowRollback: import("vue").Prop<unknown, unknown>;
+            rollback: import("vue").Prop<Function, Function>;
             renderBody: import("vue").Prop<() => JSX.Element[], () => JSX.Element[]>;
             styles: import("vue").Prop<{
                 lockingWrapper: import("typestyle/lib/types").NestedCSSProperties;
@@ -102,6 +106,8 @@ declare const _default: {
     } & Readonly<import("vue").ExtractPropTypes<{
         lockingStatus: import("vue").Prop<PropertyLockStatus, PropertyLockStatus>;
         onValueChanged: import("vue").Prop<Function, Function>;
+        allowRollback: import("vue").Prop<unknown, unknown>;
+        rollback: import("vue").Prop<Function, Function>;
         renderBody: import("vue").Prop<() => JSX.Element[], () => JSX.Element[]>;
         styles: import("vue").Prop<{
             lockingWrapper: import("typestyle/lib/types").NestedCSSProperties;
@@ -116,6 +122,8 @@ declare const _default: {
 } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
     lockingStatus: import("vue").Prop<PropertyLockStatus, PropertyLockStatus>;
     onValueChanged: import("vue").Prop<Function, Function>;
+    allowRollback: import("vue").Prop<unknown, unknown>;
+    rollback: import("vue").Prop<Function, Function>;
     renderBody: import("vue").Prop<() => JSX.Element[], () => JSX.Element[]>;
     styles: import("vue").Prop<{
         lockingWrapper: import("typestyle/lib/types").NestedCSSProperties;
@@ -130,8 +138,10 @@ declare const _default: {
         };
         onValueChanged?: Function;
         renderBody?: () => JSX.Element[];
+        rollback?: Function;
         showLockConfiguration?: boolean;
         lockingStatus?: PropertyLockStatus;
+        allowRollback?: unknown;
     }>, never>;
 };
 export default _default;

package/internal-do-not-import-from-here/ux/properties/property-picker/PropertyInput.d.ts

@@ -8,6 +8,10 @@ declare const _default: {
             style?: unknown;
             class?: unknown;
             key?: string | number | symbol;
+            readonly dark?: boolean;
+            readonly filled?: boolean;
+            readonly multiple?: boolean;
+            readonly disabled?: boolean;
             ref?: import("vue").VNodeRef;
             ref_for?: boolean;
             ref_key?: string;
@@ -49,15 +53,12 @@ declare const _default: {
             }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                 [key: string]: any;
             }>) => void)[];
-            readonly dark?: boolean;
-            readonly filled?: boolean;
-            readonly multiple?: boolean;
-            readonly disabled?: boolean;
             readonly valueBind?: PropertyRegistration;
             readonly onValueChanged?: (model: PropertyRegistration) => void;
             readonly hideDetails?: boolean;
             readonly propertyRegistrations?: PropertyRegistration[];
             readonly loadingProperties?: boolean;
+            readonly propertyCreator?: import("@omnia/fx/services").IDataSourcePropertyCreator;
         };
         $attrs: {
             [x: string]: unknown;
@@ -82,6 +83,7 @@ declare const _default: {
             multiple?: import("vue").Prop<boolean, boolean>;
             propertyRegistrations: import("vue").Prop<PropertyRegistration[], PropertyRegistration[]>;
             loadingProperties: import("vue").Prop<boolean, boolean>;
+            propertyCreator: import("vue").Prop<import("@omnia/fx/services").IDataSourcePropertyCreator, import("@omnia/fx/services").IDataSourcePropertyCreator>;
         }>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}> & {
             beforeCreate?: (() => void) | (() => void)[];
             created?: (() => void) | (() => void)[];
@@ -112,6 +114,7 @@ declare const _default: {
         multiple?: import("vue").Prop<boolean, boolean>;
         propertyRegistrations: import("vue").Prop<PropertyRegistration[], PropertyRegistration[]>;
         loadingProperties: import("vue").Prop<boolean, boolean>;
+        propertyCreator: import("vue").Prop<import("@omnia/fx/services").IDataSourcePropertyCreator, import("@omnia/fx/services").IDataSourcePropertyCreator>;
     }>> & import("vue").ShallowUnwrapRef<{}> & {} & import("vue").ComponentCustomProperties & {};
     __isFragment?: never;
     __isTeleport?: never;
@@ -126,6 +129,7 @@ declare const _default: {
     multiple?: import("vue").Prop<boolean, boolean>;
     propertyRegistrations: import("vue").Prop<PropertyRegistration[], PropertyRegistration[]>;
     loadingProperties: import("vue").Prop<boolean, boolean>;
+    propertyCreator: import("vue").Prop<import("@omnia/fx/services").IDataSourcePropertyCreator, import("@omnia/fx/services").IDataSourcePropertyCreator>;
 }>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
     propsDefinition: Omit<Readonly<{} & {
         dark?: boolean;
@@ -137,6 +141,7 @@ declare const _default: {
         hideDetails?: boolean;
         propertyRegistrations?: PropertyRegistration[];
         loadingProperties?: boolean;
+        propertyCreator?: import("@omnia/fx/services").IDataSourcePropertyCreator;
     }>, never>;
 };
 export default _default;