@omnia/fx 7.1.553-dev → 7.5.1-dev

package/internal-do-not-import-from-here/ux/properties/builtins/media/MediaDisplay.d.ts

@@ -1,5 +1,4 @@
-import { IPropertyDisplayRenderer } from "@omnia/fx-models";
-import { MediaPropertyDefinition } from "./MediaPropertyDefinition";
+import { IPropertyDisplayRenderer, MediaPropertyDefinition } from "@omnia/fx-models";
 declare const _default: (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd"), {}, import("vue-tsx-support").PropsForOutside<IPropertyDisplayRenderer<MediaPropertyDefinition>, never>, any, any, any>> & {
     propsDefinition: import("vue-tsx-support").PropsForOutside<IPropertyDisplayRenderer<MediaPropertyDefinition>, never>;
 }) | (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd") & import("vue").ShallowUnwrapRef<any>, {}, import("vue-tsx-support").PropsForOutside<IPropertyDisplayRenderer<MediaPropertyDefinition>, never>, any, any, any>> & {

package/internal-do-not-import-from-here/ux/properties/builtins/media/MediaEditor.d.ts

@@ -1,5 +1,4 @@
-import { IPropertyEditorRenderer } from "@omnia/fx-models";
-import { MediaPropertyDefinition } from "./MediaPropertyDefinition";
+import { IPropertyEditorRenderer, MediaPropertyDefinition } from "@omnia/fx-models";
 declare const _default: (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd"), {}, import("vue-tsx-support").PropsForOutside<IPropertyEditorRenderer<MediaPropertyDefinition>, never>, any, any, any>> & {
     propsDefinition: import("vue-tsx-support").PropsForOutside<IPropertyEditorRenderer<MediaPropertyDefinition>, never>;
 }) | (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd") & import("vue").ShallowUnwrapRef<any>, {}, import("vue-tsx-support").PropsForOutside<IPropertyEditorRenderer<MediaPropertyDefinition>, never>, any, any, any>> & {

package/internal-do-not-import-from-here/ux/properties/builtins/media/MediaPropertyDefinition.d.ts

@@ -1,5 +1 @@
-import { Guid, ImageDisplaySettings, ImageEditorSettings, MediaPropertyValue, PropertyDefinition } from "@omnia/fx-models";
-export declare class MediaPropertyDefinition extends PropertyDefinition<MediaPropertyValue, ImageDisplaySettings, ImageEditorSettings> {
-    id: Guid;
-    typeName: string;
-}
+export {};

package/internal-do-not-import-from-here/ux/properties/builtins/multiline-text/MultilineTextDisplay.css.d.ts

@@ -4,4 +4,6 @@ import { types } from "typestyle";
  */
 export declare const MultilineTextDisplayStyles: {
     container: types.NestedCSSProperties;
+    itemHeader: types.NestedCSSProperties;
+    item: types.NestedCSSProperties;
 };

package/internal-do-not-import-from-here/ux/properties/builtins/multiline-text/MultilineTextDisplay.d.ts

@@ -1,5 +1,4 @@
-import { IPropertyDisplayRenderer } from "@omnia/fx-models";
-import { MultilineTextPropertyDefinition } from "./MultilineTextPropertyDefinition";
+import { IPropertyDisplayRenderer, MultilineTextPropertyDefinition } from "@omnia/fx-models";
 export type MultilineTextDisplayProps = IPropertyDisplayRenderer<MultilineTextPropertyDefinition>;
 declare const _default: (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd"), {}, import("vue-tsx-support").PropsForOutside<MultilineTextDisplayProps, never>, any, any, any>> & {
     propsDefinition: import("vue-tsx-support").PropsForOutside<MultilineTextDisplayProps, never>;

package/internal-do-not-import-from-here/ux/properties/builtins/multiline-text/MultilineTextEditor.d.ts

@@ -1,5 +1,4 @@
-import { IPropertyEditorRenderer } from "@omnia/fx-models";
-import { MultilineTextPropertyDefinition } from "./MultilineTextPropertyDefinition";
+import { IPropertyEditorRenderer, MultilineTextPropertyDefinition } from "@omnia/fx-models";
 export type MultilineTextEditorProps = IPropertyEditorRenderer<MultilineTextPropertyDefinition>;
 declare const _default: (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd"), {}, import("vue-tsx-support").PropsForOutside<MultilineTextEditorProps, never>, any, any, any>> & {
     propsDefinition: import("vue-tsx-support").PropsForOutside<MultilineTextEditorProps, never>;

package/internal-do-not-import-from-here/ux/properties/builtins/multiline-text/MultilineTextPropertyDefinition.d.ts

@@ -1,11 +1 @@
-import { Guid, MultilineTextPropertyValue, PropertyDefinition, PropertyDisplaySettingsBase } from "@omnia/fx-models";
-export declare class MultilineTextDisplaySettings extends PropertyDisplaySettingsBase {
-    inline?: boolean;
-}
-export type MultilineTextEditorSettings = {
-    required?: boolean;
-};
-export declare class MultilineTextPropertyDefinition extends PropertyDefinition<MultilineTextPropertyValue, MultilineTextDisplaySettings, MultilineTextEditorSettings> {
-    id: Guid;
-    typeName: string;
-}
+export {};

package/internal-do-not-import-from-here/ux/properties/builtins/multilingualText/MultilingualTextDisplay.css.d.ts

@@ -4,4 +4,6 @@ import { types } from "typestyle";
  */
 export declare const MultilingualTextDisplayStyles: {
     container: types.NestedCSSProperties;
+    itemHeader: types.NestedCSSProperties;
+    item: types.NestedCSSProperties;
 };

package/internal-do-not-import-from-here/ux/properties/builtins/multilingualText/MultilingualTextDisplay.d.ts

@@ -1,5 +1,4 @@
-import { IPropertyDisplayRenderer } from "@omnia/fx-models";
-import { MultilingualTextPropertyDefinition } from "./MultilingualTextPropertyDefinition";
+import { IPropertyDisplayRenderer, MultilingualTextPropertyDefinition } from "@omnia/fx-models";
 export type TextDisplayProps = IPropertyDisplayRenderer<MultilingualTextPropertyDefinition>;
 declare const _default: (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd"), {}, import("vue-tsx-support").PropsForOutside<TextDisplayProps, never>, any, any, any>> & {
     propsDefinition: import("vue-tsx-support").PropsForOutside<TextDisplayProps, never>;

package/internal-do-not-import-from-here/ux/properties/builtins/multilingualText/MultilingualTextEditor.d.ts

@@ -1,5 +1,4 @@
-import { IPropertyEditorRenderer } from "@omnia/fx-models";
-import { MultilingualTextPropertyDefinition } from "./MultilingualTextPropertyDefinition";
+import { IPropertyEditorRenderer, MultilingualTextPropertyDefinition } from "@omnia/fx-models";
 export type TextEditorProps = IPropertyEditorRenderer<MultilingualTextPropertyDefinition>;
 declare const _default: (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd"), {}, import("vue-tsx-support").PropsForOutside<TextEditorProps, never>, any, any, any>> & {
     propsDefinition: import("vue-tsx-support").PropsForOutside<TextEditorProps, never>;

package/internal-do-not-import-from-here/ux/properties/builtins/multilingualText/MultilingualTextPropertyDefinition.d.ts

@@ -1,14 +1 @@
-import { Guid, MultilingualTextPropertyValue, PropertyDefinition, PropertyDisplaySettingsBase } from "@omnia/fx-models";
-export declare class MultilinugalTextDisplaySettings extends PropertyDisplaySettingsBase {
-    inline?: boolean;
-}
-export type MultilinugalTextEditorSettings = {
-    required?: boolean;
-    maxLength?: number;
-    multiLine?: boolean;
-    rows?: number;
-};
-export declare class MultilingualTextPropertyDefinition extends PropertyDefinition<MultilingualTextPropertyValue, MultilinugalTextDisplaySettings, MultilinugalTextEditorSettings> {
-    id: Guid;
-    typeName: string;
-}
+export {};

package/internal-do-not-import-from-here/ux/properties/builtins/phone-number/PhoneNumberDisplay.css.d.ts

@@ -4,4 +4,6 @@ import { types } from "typestyle";
  */
 export declare const MobileDisplayStyles: {
     container: types.NestedCSSProperties;
+    itemHeader: types.NestedCSSProperties;
+    item: types.NestedCSSProperties;
 };

package/internal-do-not-import-from-here/ux/properties/builtins/phone-number/PhoneNumberDisplay.d.ts

@@ -1,6 +1,5 @@
 import { MobileDisplayStyles } from "./PhoneNumberDisplay.css";
-import { IPropertyDisplayRenderer } from "@omnia/fx-models";
-import { PhoneNumberPropertyDefinition } from "./PhoneNumberPropertyDefinition";
+import { IPropertyDisplayRenderer, PhoneNumberPropertyDefinition } from "@omnia/fx-models";
 export type MobileDisplayProps = IPropertyDisplayRenderer<PhoneNumberPropertyDefinition> & {
     styles: typeof MobileDisplayStyles;
 };

package/internal-do-not-import-from-here/ux/properties/builtins/phone-number/PhoneNumberEditor.d.ts

@@ -1,5 +1,4 @@
-import { IPropertyEditorRenderer } from "@omnia/fx-models";
-import { PhoneNumberPropertyDefinition } from "./PhoneNumberPropertyDefinition";
+import { IPropertyEditorRenderer, PhoneNumberPropertyDefinition } from "@omnia/fx-models";
 declare const _default: (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd"), {}, import("vue-tsx-support").PropsForOutside<IPropertyEditorRenderer<PhoneNumberPropertyDefinition>, never>, any, any, any>> & {
     propsDefinition: import("vue-tsx-support").PropsForOutside<IPropertyEditorRenderer<PhoneNumberPropertyDefinition>, never>;
 }) | (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd") & import("vue").ShallowUnwrapRef<any>, {}, import("vue-tsx-support").PropsForOutside<IPropertyEditorRenderer<PhoneNumberPropertyDefinition>, never>, any, any, any>> & {

package/internal-do-not-import-from-here/ux/properties/builtins/phone-number/PhoneNumberPropertyDefinition.d.ts

@@ -1,11 +1 @@
-import { Guid, PhoneNumberPropertyValue, PropertyDefinition, PropertyDisplaySettingsBase } from "@omnia/fx-models";
-export declare class PhoneDisplaySettings extends PropertyDisplaySettingsBase {
-    inline?: boolean;
-}
-export type PhoneEditorSettings = {
-    required: boolean;
-};
-export declare class PhoneNumberPropertyDefinition extends PropertyDefinition<PhoneNumberPropertyValue, PhoneDisplaySettings, PhoneEditorSettings> {
-    id: Guid;
-    typeName: string;
-}
+export {};

package/internal-do-not-import-from-here/ux/properties/builtins/text/TextDisplay.css.d.ts

@@ -4,4 +4,6 @@ import { types } from "typestyle";
  */
 export declare const TextDisplayStyles: {
     container: types.NestedCSSProperties;
+    itemHeader: types.NestedCSSProperties;
+    item: types.NestedCSSProperties;
 };

package/internal-do-not-import-from-here/ux/properties/builtins/text/TextDisplay.d.ts

@@ -1,5 +1,4 @@
-import { IPropertyDisplayRenderer } from "@omnia/fx-models";
-import { TextPropertyDefinition } from "./TextPropertyDefinition";
+import { IPropertyDisplayRenderer, TextPropertyDefinition } from "@omnia/fx-models";
 export type TextDisplayProps = IPropertyDisplayRenderer<TextPropertyDefinition>;
 declare const _default: (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd"), {}, import("vue-tsx-support").PropsForOutside<TextDisplayProps, never>, any, any, any>> & {
     propsDefinition: import("vue-tsx-support").PropsForOutside<TextDisplayProps, never>;

package/internal-do-not-import-from-here/ux/properties/builtins/text/TextEditor.css.d.ts

@@ -4,4 +4,6 @@ import { types } from "typestyle";
  */
 export declare const TextEditorStyles: {
     container: types.NestedCSSProperties;
+    itemHeader: types.NestedCSSProperties;
+    item: types.NestedCSSProperties;
 };

package/internal-do-not-import-from-here/ux/properties/builtins/text/TextEditor.d.ts

@@ -1,5 +1,4 @@
-import { IPropertyEditorRenderer } from "@omnia/fx-models";
-import { TextPropertyDefinition } from "./TextPropertyDefinition";
+import { IPropertyEditorRenderer, TextPropertyDefinition } from "@omnia/fx-models";
 export type TextEditorProps = IPropertyEditorRenderer<TextPropertyDefinition>;
 declare const _default: (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd"), {}, import("vue-tsx-support").PropsForOutside<TextEditorProps, never>, any, any, any>> & {
     propsDefinition: import("vue-tsx-support").PropsForOutside<TextEditorProps, never>;

package/internal-do-not-import-from-here/ux/properties/builtins/text/TextPropertyDefinition.d.ts

@@ -1,15 +1 @@
-import { Guid, PropertyDefinition, PropertyDisplaySettingsBase, TextPropertyValue } from "@omnia/fx-models";
-export declare class TextDisplaySettings extends PropertyDisplaySettingsBase {
-    inline?: boolean;
-}
-export type TextEditorSettings = {
-    required?: boolean;
-    maxLength?: number;
-    multiLine?: boolean;
-    disallowWhiteSpace?: boolean;
-    rows?: number;
-};
-export declare class TextPropertyDefinition extends PropertyDefinition<TextPropertyValue, TextDisplaySettings, TextEditorSettings> {
-    id: Guid;
-    typeName: string;
-}
+export {};

package/internal-do-not-import-from-here/ux/properties/builtins/time/TimeDisplay.css.d.ts

@@ -4,4 +4,6 @@ import { types } from "typestyle";
  */
 export declare const TimeDisplayStyles: {
     container: types.NestedCSSProperties;
+    itemHeader: types.NestedCSSProperties;
+    item: types.NestedCSSProperties;
 };

package/internal-do-not-import-from-here/ux/properties/builtins/time/TimeDisplay.d.ts

@@ -1,6 +1,5 @@
 import { TimeDisplayStyles } from "./TimeDisplay.css";
-import { IPropertyDisplayRenderer } from "@omnia/fx-models";
-import { TimePropertyDefinition } from "./TimePropertyDefinition";
+import { IPropertyDisplayRenderer, TimePropertyDefinition } from "@omnia/fx-models";
 export type TimeDisplayProps = IPropertyDisplayRenderer<TimePropertyDefinition> & {
     styles: typeof TimeDisplayStyles;
 };

package/internal-do-not-import-from-here/ux/properties/builtins/time/TimeEditor.d.ts

@@ -1,6 +1,5 @@
 import { TimeEditorStyles } from "./TimeEditor.css";
-import { IPropertyEditorRenderer } from "@omnia/fx-models";
-import { TimePropertyDefinition } from "./TimePropertyDefinition";
+import { IPropertyEditorRenderer, TimePropertyDefinition } from "@omnia/fx-models";
 export type TimeEditorProps = IPropertyEditorRenderer<TimePropertyDefinition> & {
     styles: typeof TimeEditorStyles;
 };

package/internal-do-not-import-from-here/ux/properties/builtins/time/TimePropertyDefinition.d.ts

@@ -1,16 +1 @@
-import { Guid, Primitive, PropertyDefinition, PropertyDisplaySettingsBase, PropertyValue } from "@omnia/fx-models";
-export declare class TimePropertyValue extends PropertyValue<TimePropertyValue, Date> {
-    primitive: Primitive<TimePropertyValue, Date>;
-    time: Date;
-    timeZoneId: string;
-}
-export type TimeDisplaySettings = {
-    fontSize: number;
-} & PropertyDisplaySettingsBase;
-export type TimeEditorSettings = {
-    required: boolean;
-};
-export declare class TimePropertyDefinition extends PropertyDefinition<TimePropertyValue, TimeDisplaySettings, TimeEditorSettings> {
-    id: Guid;
-    typeName: string;
-}
+export {};

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

@@ -1,4 +1,2 @@
 export * from "./models";
 export * from "./apis";
-export * from "./LegacyEnterprisePropertiesProvider";
-export * from "./PropertyDataSourceContext";

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

@@ -1,29 +1,36 @@
-import { PropertyBinding, PropertyConfiguration, PropertyDefinition, PropertyValue, PropertyValueBinding } from "@omnia/fx-models";
-import { DataSourcePropertyBinding } from "internal/fx/models/properties/DataSourcePropertyBinding";
-import { GuidValue } from "../../../shared/models";
-export type PropertyDataSourceRegistrationId = GuidValue;
-export declare abstract class PropertyDataSourceBase {
-    title: string;
-    id: PropertyDataSourceRegistrationId;
-    abstract supportsWriteback(property: PropertyConfiguration<PropertyDefinition<any, any, any>>): boolean;
-    abstract onSavePropertyValue(properties: PropertyValueBinding<PropertyDefinition<any, any, any> | PropertyValue<any, any>>[]): Promise<void>;
-    abstract getProperties(): Promise<Array<DataSourcePropertyBinding>>;
-    abstract getPropertyValue(property: PropertyConfiguration<PropertyDefinition<any, any, any>>): Promise<PropertyValueBinding<PropertyDefinition<any, any, any>>>;
-    abstract getPropertyBinding(property: PropertyConfiguration<PropertyDefinition<any, any, any>>): Promise<PropertyBinding<PropertyDefinition<any, any, any>>>;
+import { PropertyDataSourceId, PropertyDefinition } from "@omnia/fx-models";
+import { PropertyDataSourceBase, DataSourcePropertyDefinitionHandler } from "@omnia/fx/services";
+import { DataSourceProperty } from "internal/fx/models/properties/datasource/DataSourceProperty";
+import { PropertyDefinitionId } from "./Properties";
+export interface IPropertyDataSourceRegistrationApi extends IRegisteredPropertyDataSourceApi {
+    /**
+     * Register a property data source
+     * */
+    registerDataSource2<TDataSourceProperty extends DataSourceProperty>(registration: new () => PropertyDataSourceBase<TDataSourceProperty>): void;
+    /**
+     * Register a property handler for the specific datasource, such a handler looks at the TDataSourceProperty and checks if this should be converted to the property defintion this handler is created/registered to handle
+     * */
+    registerDataSourcePropertyDefintionHandler2<TDataSourceProperty extends DataSourceProperty, TPropertyDefinition extends PropertyDefinition<any, any, any>>(dataSource: new () => PropertyDataSourceBase<TDataSourceProperty>, propertyDefinitionHandlerCtor: new () => DataSourcePropertyDefinitionHandler<TPropertyDefinition, TDataSourceProperty, any, any>): any;
 }
-export interface IPropertyDataSourceRegistrationApi {
-    register(registrations: new () => PropertyDataSourceBase | Array<new () => PropertyDataSourceBase>): void;
-    getDataSources(): Promise<(new () => PropertyDataSourceBase)[]>;
-    getDataSource(dataSourceId: PropertyDataSourceRegistrationId): Promise<new () => PropertyDataSourceBase>;
+/**
+ * We work on registered datasources without any care about implementing type, i.e. none generic for getting
+ * */
+export interface IRegisteredPropertyDataSourceApi {
+    getDataSources(): Promise<(new () => PropertyDataSourceBase<DataSourceProperty>)[]>;
+    getDataSource(dataSourceId: PropertyDataSourceId): Promise<new () => PropertyDataSourceBase<DataSourceProperty>>;
+    getDataSourceDefinitionHandlers(dataSourceId: PropertyDataSourceId): Promise<Array<{
+        propertyDefintionId: PropertyDefinitionId;
+        handlerCtor: new () => DataSourcePropertyDefinitionHandler<PropertyDefinition<any, any, any>, DataSourceProperty, any, any>;
+    }>>;
 }
 export interface IPropertyDataSourceProvider {
 }
 export declare class PropertyDataSourceProviderRegistration {
-    typeId: PropertyDataSourceRegistrationId;
+    typeId: PropertyDataSourceId;
     provider: new () => IPropertyDataSourceProvider;
-    constructor(typeId: PropertyDataSourceRegistrationId, provider: new () => IPropertyDataSourceProvider);
+    constructor(typeId: PropertyDataSourceId, provider: new () => IPropertyDataSourceProvider);
 }
 export interface IPropertyDataSourceProviderApi {
     register(registration: PropertyDataSourceProviderRegistration): void;
-    getProvider(typeId: PropertyDataSourceRegistrationId): Promise<new () => IPropertyDataSourceProvider>;
+    getProvider(typeId: PropertyDataSourceId): Promise<new () => IPropertyDataSourceProvider>;
 }

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

@@ -1,8 +1,9 @@
-import { EnterprisePropertyDefinition, IExtendApiManifestWithConfiguration, PropertyDefinition } from "@omnia/fx-models";
+import { EnterprisePropertyDefinition, IExtendApiManifestWithConfiguration, PropertyDataSourceId, PropertyDefinition } from "@omnia/fx-models";
 import { GuidValue } from "../../../shared/models";
 import { VueComponentBase } from "../../VueComponentBase";
 import { PropertyDefinitionId, PropertySettings } from "./Properties";
-import { IPropertyDataSourceRegistrationApi, PropertyDataSourceRegistrationId } from "./DataSource";
+import { IPropertyDataSourceRegistrationApi } from "./DataSource";
+import { DataSourcePropertyDefintionHandlerId } from "@omnia/fx/services";
 export type PropertyRegistrationId = GuidValue;
 export interface PropertyRegistration {
     id: PropertyRegistrationId;
@@ -45,7 +46,17 @@ declare module "@omnia/fx-models" {
         properties: {
             definitions: IExtendApiManifestWithConfiguration<PropertyDefinitionId>;
             dataSources: {
-                registrations: IExtendApiManifestWithConfiguration<PropertyDataSourceRegistrationId>;
+                /**
+                 * Register the manifest/bundle that contains the propertydatasource
+                 * */
+                registrations: IExtendApiManifestWithConfiguration<PropertyDataSourceId>;
+                /**
+                 * Register any external plugin/dataSourcePropertyDefinitionHandler for a property data source
+                 * */
+                pluginRegistration: IExtendApiManifestWithConfiguration<{
+                    dataSourceId: PropertyDataSourceId;
+                    dataSourcePropertyDefinitionHandlerId: DataSourcePropertyDefintionHandlerId;
+                }>;
             };
         };
     }

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

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

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

@@ -1,10 +1,19 @@
-import { DataSourcePropertyBinding } from "internal/fx/models/properties/DataSourcePropertyBinding";
+import { DataSourceProperty, GuidValue, PropertyConfiguration, PropertyDataSourceId, PropertyDefinition } from "@omnia/fx-models";
+import { DataSourcePropertyDefintionHandlerId } from "../../../services";
+export interface IDataSourcePropertySelection {
+    dataSourceProperty: DataSourceProperty;
+    selectedConverter: DataSourcePropertyDefintionHandlerId;
+    propertyConfiguration?: PropertyConfiguration<PropertyDefinition<any, any, any>>;
+}
 export interface IPropertyPicker {
-    valueBind: DataSourcePropertyBinding;
-    onValueChanged?: (model: DataSourcePropertyBinding) => void;
+    selectableDataSources: Array<PropertyDataSourceId>;
+    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

@@ -2,5 +2,4 @@ export * from "./Properties";
 export * from "./DataSource";
 export * from "./PropertyApi";
 export * from "./PropertyPicker";
-export * from "./PropertySelection";
-export * from "./PropertyInput";
+export * from "./PropertySettingsLock";

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

@@ -0,0 +1,8 @@
+import { PropertyDefinition, IPropertyConfigurationRenderer, PropertyValue } from "@omnia/fx-models";
+import { LockingPropertyDisplaySettings } from "@omnia/fx/ux";
+declare const _default: (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd"), {}, import("vue-tsx-support").PropsForOutside<IPropertyConfigurationRenderer<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, any, import("@omnia/fx-models").PropertySetupBase>>, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<IPropertyConfigurationRenderer<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, any, import("@omnia/fx-models").PropertySetupBase>>, never>;
+}) | (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd") & import("vue").ShallowUnwrapRef<any>, {}, import("vue-tsx-support").PropsForOutside<IPropertyConfigurationRenderer<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, any, import("@omnia/fx-models").PropertySetupBase>>, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<IPropertyConfigurationRenderer<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

@@ -0,0 +1,8 @@
+import { PropertyDefinition, IPropertyConfigurationRenderer, PropertyValue } from "@omnia/fx-models";
+import { LockingPropertyDisplaySettings } from "@omnia/fx/ux";
+declare const _default: (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd"), {}, import("vue-tsx-support").PropsForOutside<IPropertyConfigurationRenderer<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, any, import("@omnia/fx-models").PropertySetupBase>>, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<IPropertyConfigurationRenderer<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, any, import("@omnia/fx-models").PropertySetupBase>>, never>;
+}) | (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd") & import("vue").ShallowUnwrapRef<any>, {}, import("vue-tsx-support").PropsForOutside<IPropertyConfigurationRenderer<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, any, import("@omnia/fx-models").PropertySetupBase>>, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<IPropertyConfigurationRenderer<PropertyDefinition<PropertyValue, LockingPropertyDisplaySettings, any, import("@omnia/fx-models").PropertySetupBase>>, never>;
+});
+export default _default;

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

@@ -0,0 +1,7 @@
+import { types } from "typestyle";
+/**
+ * Styles for the PropertyLocking component
+ */
+export declare const PropertyLockingStyles: {
+    lockingWrapper: types.NestedCSSProperties;
+};

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

@@ -0,0 +1,47 @@
+import { PropertyLockStatus } from "@omnia/fx/ux";
+declare const _default: (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd"), {}, import("vue-tsx-support").PropsForOutside<{
+    lockingStatus: PropertyLockStatus;
+    onValueChanged: Function;
+    allowRollback: unknown;
+    rollback: Function;
+    renderBody: () => JSX.Element[];
+    styles: {
+        lockingWrapper: import("typestyle/lib/types").NestedCSSProperties;
+    };
+    showLockConfiguration: boolean;
+}, "onValueChanged" | "renderBody">, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<{
+        lockingStatus: PropertyLockStatus;
+        onValueChanged: Function;
+        allowRollback: unknown;
+        rollback: Function;
+        renderBody: () => JSX.Element[];
+        styles: {
+            lockingWrapper: import("typestyle/lib/types").NestedCSSProperties;
+        };
+        showLockConfiguration: boolean;
+    }, "onValueChanged" | "renderBody">;
+}) | (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd") & import("vue").ShallowUnwrapRef<() => VueTsxSupport.JSX.Element>, {}, import("vue-tsx-support").PropsForOutside<{
+    lockingStatus: PropertyLockStatus;
+    onValueChanged: Function;
+    allowRollback: unknown;
+    rollback: Function;
+    renderBody: () => JSX.Element[];
+    styles: {
+        lockingWrapper: import("typestyle/lib/types").NestedCSSProperties;
+    };
+    showLockConfiguration: boolean;
+}, "onValueChanged" | "renderBody">, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<{
+        lockingStatus: PropertyLockStatus;
+        onValueChanged: Function;
+        allowRollback: unknown;
+        rollback: Function;
+        renderBody: () => JSX.Element[];
+        styles: {
+            lockingWrapper: import("typestyle/lib/types").NestedCSSProperties;
+        };
+        showLockConfiguration: boolean;
+    }, "onValueChanged" | "renderBody">;
+});
+export default _default;

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

@@ -1,4 +1,4 @@
-import { IPropertyInput } from "@omnia/fx/ux";
+import { IPropertyInput } from "../models/PropertyInput";
 declare const _default: (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd"), {}, import("vue-tsx-support").PropsForOutside<IPropertyInput, never>, any, any, any>> & {
     propsDefinition: import("vue-tsx-support").PropsForOutside<IPropertyInput, never>;
 }) | (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd") & import("vue").ShallowUnwrapRef<any>, {}, import("vue-tsx-support").PropsForOutside<IPropertyInput, never>, any, any, any>> & {

package/internal-do-not-import-from-here/ux/properties/property-renderer/PropertyBindingValueRenderer.d.ts

@@ -0,0 +1,27 @@
+import { PropertyDefinition, PropertyValue, PropertyValueBinding } from "@omnia/fx-models";
+declare const _default: (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd"), {}, import("vue-tsx-support").PropsForOutside<{
+    valueBind: PropertyValueBinding<PropertyDefinition<PropertyValue, any, any, import("@omnia/fx-models").PropertySetupBase>>;
+    onValueBindChanged: (newValue: PropertyValueBinding<PropertyDefinition<PropertyValue, any, any>>) => void;
+    disabled: boolean;
+    editMode: boolean;
+}, "valueBind">, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<{
+        valueBind: PropertyValueBinding<PropertyDefinition<PropertyValue, any, any, import("@omnia/fx-models").PropertySetupBase>>;
+        onValueBindChanged: (newValue: PropertyValueBinding<PropertyDefinition<PropertyValue, any, any>>) => void;
+        disabled: boolean;
+        editMode: boolean;
+    }, "valueBind">;
+}) | (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd") & import("vue").ShallowUnwrapRef<() => VueTsxSupport.JSX.Element>, {}, import("vue-tsx-support").PropsForOutside<{
+    valueBind: PropertyValueBinding<PropertyDefinition<PropertyValue, any, any, import("@omnia/fx-models").PropertySetupBase>>;
+    onValueBindChanged: (newValue: PropertyValueBinding<PropertyDefinition<PropertyValue, any, any>>) => void;
+    disabled: boolean;
+    editMode: boolean;
+}, "valueBind">, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<{
+        valueBind: PropertyValueBinding<PropertyDefinition<PropertyValue, any, any, import("@omnia/fx-models").PropertySetupBase>>;
+        onValueBindChanged: (newValue: PropertyValueBinding<PropertyDefinition<PropertyValue, any, any>>) => void;
+        disabled: boolean;
+        editMode: boolean;
+    }, "valueBind">;
+});
+export default _default;

package/internal-do-not-import-from-here/ux/properties/property-renderer/PropertyValueRenderer.d.ts

@@ -0,0 +1,35 @@
+import { PropertyDefinition, PropertyConfiguration, PropertyValue } from "@omnia/fx-models";
+declare const _default: (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd"), {}, import("vue-tsx-support").PropsForOutside<{
+    valueBind: PropertyValue;
+    propertyDefintionId: import("@omnia/fx-models").GuidValue;
+    configuration: PropertyConfiguration<PropertyDefinition<any, any, any, import("@omnia/fx-models").PropertySetupBase>>;
+    onValueBindChanged: (newValue: PropertyValue) => void;
+    disabled: boolean;
+    editMode: boolean;
+}, "configuration" | "valueBind" | "propertyDefintionId">, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<{
+        valueBind: PropertyValue;
+        propertyDefintionId: import("@omnia/fx-models").GuidValue;
+        configuration: PropertyConfiguration<PropertyDefinition<any, any, any, import("@omnia/fx-models").PropertySetupBase>>;
+        onValueBindChanged: (newValue: PropertyValue) => void;
+        disabled: boolean;
+        editMode: boolean;
+    }, "configuration" | "valueBind" | "propertyDefintionId">;
+}) | (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd") & import("vue").ShallowUnwrapRef<() => import("vue").VNode>, {}, import("vue-tsx-support").PropsForOutside<{
+    valueBind: PropertyValue;
+    propertyDefintionId: import("@omnia/fx-models").GuidValue;
+    configuration: PropertyConfiguration<PropertyDefinition<any, any, any, import("@omnia/fx-models").PropertySetupBase>>;
+    onValueBindChanged: (newValue: PropertyValue) => void;
+    disabled: boolean;
+    editMode: boolean;
+}, "configuration" | "valueBind" | "propertyDefintionId">, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<{
+        valueBind: PropertyValue;
+        propertyDefintionId: import("@omnia/fx-models").GuidValue;
+        configuration: PropertyConfiguration<PropertyDefinition<any, any, any, import("@omnia/fx-models").PropertySetupBase>>;
+        onValueBindChanged: (newValue: PropertyValue) => void;
+        disabled: boolean;
+        editMode: boolean;
+    }, "configuration" | "valueBind" | "propertyDefintionId">;
+});
+export default _default;

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

@@ -73,6 +73,7 @@ export default class RichTextEditor extends VueComponentBase implements IWebComp
     loadFromExtensionRegistrations(extensionSettings: RichTextEditorExtensionRegistration[]): Promise<Array<RichTextEditorExtension>>;
     buildExtensionList(extensionListFromTenantSettings: RichTextEditorExtensionRegistration[]): RichTextEditorExtension[];
     initExtensions(): void;
+    handlePastedContext(formatedText: any, formatedHtml: any, view: any, slice: any): void;
     setupEditor(): void;
     private currentEmitedContent;
     private onEditorUpdated;

package/internal-do-not-import-from-here/ux/richtexteditor/TextCompletionPanel/TextCompletionPanel.css.d.ts

@@ -0,0 +1,28 @@
+declare const _default: {
+    container: {
+        fontSize: number;
+    };
+};
+export default _default;
+export declare const containerInput: string;
+export declare const containerInputWithoutReply: string;
+export declare const componentCloseButton: string;
+export declare const componentHeader: string;
+export declare const componentBody: string;
+export declare const componentStart: string;
+export declare const componentFooter: string;
+export declare const componentMessage: string;
+export declare const componentMessageContainer: string;
+export declare const componentMessageContainerOneline: string;
+export declare const componentReply: string;
+export declare const componentReplyContainer: string;
+export declare const componentReplyContainerOneline: string;
+export declare const link: string;
+export declare const resetLink: string;
+export declare const repliedMessage: string;
+export declare const componentInsert: string;
+export declare const componentImprove: string;
+export declare const visibilityHidden: string;
+export declare const bubbleLoading: string;
+export declare const waitForTyping: string;
+export declare const repliedUserMessage: string;