@omnia/fx-models 8.0.5-vnext → 8.0.6-dev-dev

package/properties/IPropertyValueRenderer.d.ts

@@ -1,20 +1,30 @@
 import { PropertyConfiguration } from "./PropertyConfiguration";
-import { PropertyDefinition, PropertyDisplaySettingsType, PropertyEditorSettingsType, PropertyValueType } from "./PropertyDefinition";
+import { PropertyDefinition, PropertyDisplaySettingsType, PropertyEditorSettingsType, PropertySetupSettingsType, PropertyValueType } from "./PropertyDefinition";
 /**
  * Interface for webcomponent rendering a property value belonging to a property definition
  * */
 export interface IPropertyDisplayRenderer<TPropertyDef extends PropertyDefinition<any, any, any>> {
-    valueBind: PropertyValueType<TPropertyDef>;
+    modelValue: PropertyValueType<TPropertyDef>;
     displaySettings: PropertyDisplaySettingsType<TPropertyDef>;
+    setupSettings?: PropertySetupSettingsType<TPropertyDef>;
+    renderTextOnly?: boolean;
 }
 export interface IPropertyEditorRenderer<TPropertyDef extends PropertyDefinition<any, any, any>> {
-    valueBind: PropertyValueType<TPropertyDef>;
+    modelValue: PropertyValueType<TPropertyDef>;
     editorSettings: PropertyEditorSettingsType<TPropertyDef>;
     displaySettings: PropertyDisplaySettingsType<TPropertyDef>;
-    onValueBindChanged(newValue: PropertyValueType<TPropertyDef>): void;
+    setupSettings?: PropertySetupSettingsType<TPropertyDef>;
     disabled?: boolean;
 }
 export interface IPropertyConfigurationRenderer<TPropertyDef extends PropertyDefinition<any, any, any>> {
-    valueBind: PropertyConfiguration<TPropertyDef>;
-    onValueBindChanged(newValue: PropertyConfiguration<TPropertyDef>): void;
+    modelValue: PropertyConfiguration<TPropertyDef>;
+    /**
+     * Call each time the configuration is considered valid, i.e. the values of the configuration is good
+     * Also called when no longer valid, but with value null
+     * @param newValue null for invalid config state, value matching a complete configuration
+     */
+    onConfigurationValid(validConfig?: PropertyConfiguration<TPropertyDef>): void;
+    showLockConfiguration?: boolean;
+    renderEditSettings?: boolean;
+    defaultConfiguration?: PropertyConfiguration<TPropertyDef>;
 }

package/properties/PropertyBinding.d.ts

@@ -2,11 +2,11 @@ import { PropertyDefinitionId } from "@omnia/fx/ux";
 import { GuidValue } from "@omnia/fx-models/internal-do-not-import-from-here/shared/models";
 import { MultilingualString } from "../MultilingualString";
 import { PropertyDefinition } from "./PropertyDefinition";
+export type PropertyBindingId = GuidValue;
+export type PropertyBindingProviderId = GuidValue;
 export declare class PropertyBinding<TPropertyDef extends PropertyDefinition<any, any, any>> {
     readonly propertyDefinitionId: PropertyDefinitionId;
-    readonly bindingId: GuidValue;
-    readonly internalName: string;
-    displayName: MultilingualString;
-    constructor(bindingId: GuidValue, internalName: string, typeConstructor: new () => TPropertyDef, displayName?: MultilingualString);
-    constructor(bindingId: GuidValue, internalName: string, propertyDefinitionId: PropertyDefinitionId, displayName?: MultilingualString);
+    readonly bindingId: PropertyBindingId;
+    readonly displayName: MultilingualString;
+    constructor(typeDef: (new () => TPropertyDef) | TPropertyDef, bindingId: PropertyBindingId, displayName?: MultilingualString);
 }

package/properties/PropertyBinding.js

@@ -1,20 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PropertyBinding = void 0;
-const models_1 = require("@omnia/fx-models/internal-do-not-import-from-here/shared/models");
 class PropertyBinding {
-    constructor(bindingId, internalName, anyPropertyDefIdVariant, displayName) {
-        //We do not know which of the two possible ctors are used, check it.
-        if (typeof anyPropertyDefIdVariant === "string" || anyPropertyDefIdVariant instanceof models_1.Guid) {
-            this.propertyDefinitionId = anyPropertyDefIdVariant;
+    constructor(typeDef, bindingId, displayName) {
+        if (typeDef.id) {
+            this.propertyDefinitionId = typeDef.id;
         }
         else {
-            const typeConstructor = anyPropertyDefIdVariant;
-            const definitionInstance = new typeConstructor();
-            this.propertyDefinitionId = definitionInstance.id;
+            this.propertyDefinitionId = new typeDef().id;
         }
         this.bindingId = bindingId;
-        this.internalName = internalName;
         this.displayName = displayName || {};
     }
 }

package/properties/PropertyConfiguration.d.ts

@@ -1,12 +1,6 @@
-import { GuidValue } from "@omnia/fx-models/internal-do-not-import-from-here/shared/models";
-import { PropertyBinding } from "./PropertyBinding";
-import { PropertyDefinition, PropertyDisplaySettingsType, PropertyEditorSettingsType } from "./PropertyDefinition";
-export declare class PropertyConfiguration<TPropertyDef extends PropertyDefinition<any, any, any>> {
-    configurationPropertyTypeName: string;
+import { PropertyDefinition, PropertyDisplaySettingsType, PropertyEditorSettingsType, PropertySetupSettingsType } from "./PropertyDefinition";
+export interface PropertyConfiguration<TPropertyDef extends PropertyDefinition<any, any, any>> {
     propertyDisplaySettings: PropertyDisplaySettingsType<TPropertyDef>;
     propertyEditorSettings: PropertyEditorSettingsType<TPropertyDef>;
-    readonly propertyBindingId: GuidValue;
-    readonly propertyInternalName: string;
-    readonly propertyDefinitionId: GuidValue;
-    constructor(configurationPropertyTypeName: string, propertyBinding: PropertyBinding<TPropertyDef>, propertyDisplaySettings: PropertyDisplaySettingsType<TPropertyDef>, propertyEditorSettings: PropertyEditorSettingsType<TPropertyDef>);
+    propertySetupSettings?: PropertySetupSettingsType<TPropertyDef>;
 }

package/properties/PropertyConfiguration.js

@@ -1,15 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PropertyConfiguration = void 0;
-const models_1 = require("@omnia/fx-models/internal-do-not-import-from-here/shared/models");
-class PropertyConfiguration {
-    constructor(configurationPropertyTypeName, propertyBinding, propertyDisplaySettings, propertyEditorSettings) {
-        this.configurationPropertyTypeName = configurationPropertyTypeName;
-        this.propertyDisplaySettings = propertyDisplaySettings;
-        this.propertyEditorSettings = propertyEditorSettings;
-        this.propertyInternalName = propertyBinding?.internalName || configurationPropertyTypeName;
-        this.propertyBindingId = propertyBinding?.bindingId || models_1.Guid.empty;
-        this.propertyDefinitionId = propertyBinding?.propertyDefinitionId || models_1.Guid.empty;
-    }
-}
-exports.PropertyConfiguration = PropertyConfiguration;

package/properties/PropertyDefinition.d.ts

@@ -1,19 +1,52 @@
 import { GuidValue } from "@omnia/fx-models/internal-do-not-import-from-here/shared/models";
+import { IIcon } from "../Icon";
 import { MultilingualString } from "../MultilingualString";
 import { PropertyValue } from "./PropertyValue";
-export type PropertyDisplaySettingsType<TPropDef extends PropertyDefinition<any, any, any>> = TPropDef extends PropertyDefinition<any, infer TPropertyDisplaySettings, any> ? TPropertyDisplaySettings : never;
-export type PropertyEditorSettingsType<TPropDef extends PropertyDefinition<any, any, any>> = TPropDef extends PropertyDefinition<any, any, infer TPropertyEditorSettings> ? TPropertyEditorSettings : never;
-export type PropertyValueType<TPropDef> = TPropDef extends PropertyDefinition<infer TPropertyValue, any, any> ? TPropertyValue : never;
+export type PropertyDisplaySettingsType<TPropDef extends PropertyDefinition<any, any, any, any>> = TPropDef extends PropertyDefinition<any, infer TPropertyDisplaySettings, any, any> ? TPropertyDisplaySettings : never;
+export type PropertyEditorSettingsType<TPropDef extends PropertyDefinition<any, any, any, any>> = TPropDef extends PropertyDefinition<any, any, infer TPropertyEditorSettings, any> ? TPropertyEditorSettings : never;
+export type PropertySetupSettingsType<TPropDef extends PropertyDefinition<any, any, any, any>> = TPropDef extends PropertyDefinition<any, any, any, infer TPropertySetupSettings> ? (TPropertySetupSettings extends UndefinedMirrorOfPropertySetupBase ? never : TPropertySetupSettings) : never;
+export type PropertyValueType<TPropDef> = TPropDef extends PropertyDefinition<infer TPropertyValue, any, any, any> ? TPropertyValue : never;
 export type PropertyDefinitionId = GuidValue;
+export interface PropertyLabel {
+    text: string | MultilingualString;
+    icon?: IIcon;
+}
 export declare abstract class PropertyDisplaySettingsBase {
-    label?: string | MultilingualString;
+    label?: PropertyLabel;
+    showLabelText?: boolean;
+    showLabelIcon?: boolean;
+}
+export declare abstract class PropertyEditorSettingsBase {
+    required?: boolean;
+    description?: MultilingualString;
+}
+/**
+ * The base for PropertySetup
+ */
+export declare abstract class PropertySetupBase {
+}
+declare abstract class UndefinedMirrorOfPropertySetupBase extends PropertySetupBase {
+    private uniquePropertyNameOfUndefinedMirrorOfPropertySetupBase?;
 }
-export declare abstract class PropertyDefinition<TPropertyValue extends PropertyValue<any, any>, TPropertyDisplaySettings extends PropertyDisplaySettingsBase, TPropertyEditorSettings> {
+export declare abstract class PropertyDefinition<TPropertyValue extends PropertyValue, TPropertyDisplaySettings extends PropertyDisplaySettingsBase, TPropertyEditorSettings extends PropertyEditorSettingsBase, TPropertySetupSettings extends PropertySetupBase = PropertySetupBase> {
     abstract readonly id: PropertyDefinitionId;
     abstract readonly typeName: string;
-    readonly hidden?: boolean;
-    value?: TPropertyValue;
-    displaySettings?: TPropertyDisplaySettings;
-    editorSettings?: TPropertyEditorSettings;
+    /**
+     * Dummy used to not make the compiler remove the generic type info from d.ts
+     * */
+    protected value?: TPropertyValue;
+    /**
+     * Dummy used to not make the compiler remove the generic type info from d.ts
+     * */
+    protected displaySettings?: TPropertyDisplaySettings;
+    /**
+     * Dummy used to not make the compiler remove the generic type info from d.ts
+     * */
+    protected editorSettings?: TPropertyEditorSettings;
+    /**
+     * Dummy used to not make the compiler remove the generic type info from d.ts
+     * */
+    protected setupSettings?: TPropertySetupSettings;
     constructor();
 }
+export {};

package/properties/PropertyDefinition.js

@@ -1,9 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PropertyDefinition = exports.PropertyDisplaySettingsBase = void 0;
+exports.PropertyDefinition = exports.PropertySetupBase = exports.PropertyEditorSettingsBase = exports.PropertyDisplaySettingsBase = void 0;
 class PropertyDisplaySettingsBase {
 }
 exports.PropertyDisplaySettingsBase = PropertyDisplaySettingsBase;
+class PropertyEditorSettingsBase {
+}
+exports.PropertyEditorSettingsBase = PropertyEditorSettingsBase;
+//// Begining: Making the typing work for PropertyDefinition without specifying TPropertySetupSettings gives type never, i.e compile error else the correct typing if set.
+///This is kind of magic stuff getting ts to have the desired behaviour
+/**
+ * The base for PropertySetup
+ */
+class PropertySetupBase {
+}
+exports.PropertySetupBase = PropertySetupBase;
+class UndefinedMirrorOfPropertySetupBase extends PropertySetupBase {
+}
+///End
 class PropertyDefinition {
     constructor() {
     }

package/properties/PropertyValue.d.ts

@@ -1,152 +1,13 @@
 import { PropertyBinding } from ".";
-import { Guid, GuidValue } from "@omnia/fx-models/internal-do-not-import-from-here/shared/models";
-import { Identity } from "../identities";
-import { MultilingualString } from "../MultilingualString";
+import { GuidValue } from "@omnia/fx-models/internal-do-not-import-from-here/shared/models";
 import { PropertyDefinition, PropertyValueType } from "./PropertyDefinition";
-export declare enum PrimitiveType {
-    none = 0,
-    number = 1,
-    string = 2,
-    dateTime = 3,
-    guid = 4,
-    boolean = 5,
-    multilingualString = 6,
-    identity = 7
-}
-export declare enum DictionaryPrimitiveKeyType {
-    string = 1,
-    number = 2
-}
-export type Primitive<TPropertyValue extends PropertyValue<any, any>, TPrimitiveType> = TPrimitiveType extends boolean ? {
-    type: PrimitiveType.boolean;
-    path: (property: TPropertyValue) => boolean;
-} : TPrimitiveType extends number ? {
-    type: PrimitiveType.number;
-    path: (property: TPropertyValue) => number;
-} : TPrimitiveType extends string ? {
-    type: PrimitiveType.string;
-    path: (property: TPropertyValue) => string;
-} : TPrimitiveType extends Date ? {
-    type: PrimitiveType.dateTime;
-    path: (property: TPropertyValue) => Date;
-} : TPrimitiveType extends Guid ? {
-    type: PrimitiveType.guid;
-    path: (property: TPropertyValue) => Guid;
-} : TPrimitiveType extends MultilingualString ? {
-    type: PrimitiveType.multilingualString;
-    path: (property: TPropertyValue) => MultilingualString;
-} : TPrimitiveType extends Identity ? {
-    type: PrimitiveType.identity;
-    path: (property: TPropertyValue) => Identity;
-} : never;
-export type PrimitiveArray<TPropertyValue extends PropertyValue<any, any>, TPrimitiveType> = TPrimitiveType extends boolean[] ? {
-    type: PrimitiveType.boolean;
-    arrayValueType: PrimitiveType.boolean;
-    path: (property: TPropertyValue) => boolean[];
-} : TPrimitiveType extends number[] ? {
-    type: PrimitiveType.number;
-    arrayValueType: PrimitiveType.number;
-    path: (property: TPropertyValue) => number[];
-} : TPrimitiveType extends string[] ? {
-    type: PrimitiveType.string;
-    arrayValueType: PrimitiveType.string;
-    path: (property: TPropertyValue) => string[];
-} : TPrimitiveType extends Date[] ? {
-    type: PrimitiveType.dateTime;
-    arrayValueType: PrimitiveType.dateTime;
-    path: (property: TPropertyValue) => Date[];
-} : TPrimitiveType extends Guid[] ? {
-    type: PrimitiveType.guid;
-    arrayValueType: PrimitiveType.guid;
-    path: (property: TPropertyValue) => Guid[];
-} : TPrimitiveType extends MultilingualString[] ? {
-    type: PrimitiveType.multilingualString;
-    arrayValueType: PrimitiveType.multilingualString;
-    path: (property: TPropertyValue) => MultilingualString[];
-} : TPrimitiveType extends Identity[] ? {
-    type: PrimitiveType.identity;
-    arrayValueType: PrimitiveType.identity;
-    path: (property: TPropertyValue) => Identity[];
-} : never;
-export type PrimitiveDictionary<TPropertyValue extends PropertyValue<any, any>, TPrimitiveType, TDictionaryKey extends DictionaryPrimitiveKeyType = DictionaryPrimitiveKeyType> = TDictionaryKey extends DictionaryPrimitiveKeyType.string ? TPrimitiveType extends boolean ? {
-    type: PrimitiveType.boolean;
-    dictionaryKeyType: DictionaryPrimitiveKeyType.string;
-    path: (property: TPropertyValue) => {
-        [key: string]: boolean;
-    };
-} : TPrimitiveType extends number ? {
-    type: PrimitiveType.number;
-    dictionaryKeyType: DictionaryPrimitiveKeyType.string;
-    path: (property: TPropertyValue) => {
-        [key: string]: number;
-    };
-} : TPrimitiveType extends string ? {
-    type: PrimitiveType.string;
-    dictionaryKeyType: DictionaryPrimitiveKeyType.string;
-    path: (property: TPropertyValue) => {
-        [key: string]: string;
-    };
-} : TPrimitiveType extends Date ? {
-    type: PrimitiveType.dateTime;
-    dictionaryKeyType: DictionaryPrimitiveKeyType.string;
-    path: (property: TPropertyValue) => {
-        [key: string]: Date;
-    };
-} : TPrimitiveType extends Guid ? {
-    type: PrimitiveType.guid;
-    dictionaryKeyType: DictionaryPrimitiveKeyType.string;
-    path: (property: TPropertyValue) => {
-        [key: string]: Guid;
-    };
-} : TPrimitiveType extends Identity ? {
-    type: PrimitiveType.identity;
-    dictionaryKeyType: DictionaryPrimitiveKeyType.string;
-    path: (property: TPropertyValue) => {
-        [key: string]: Identity;
-    };
-} : never : TDictionaryKey extends DictionaryPrimitiveKeyType.number ? TPrimitiveType extends boolean ? {
-    type: PrimitiveType.boolean;
-    dictionaryKeyType: DictionaryPrimitiveKeyType.string;
-    path: (property: TPropertyValue) => {
-        [key: number]: boolean;
-    };
-} : TPrimitiveType extends number ? {
-    type: PrimitiveType.number;
-    dictionaryKeyType: DictionaryPrimitiveKeyType.number;
-    path: (property: TPropertyValue) => {
-        [key: number]: number;
-    };
-} : TPrimitiveType extends string ? {
-    type: PrimitiveType.string;
-    dictionaryKeyType: DictionaryPrimitiveKeyType.number;
-    path: (property: TPropertyValue) => {
-        [key: number]: string;
-    };
-} : TPrimitiveType extends Date ? {
-    type: PrimitiveType.dateTime;
-    dictionaryKeyType: DictionaryPrimitiveKeyType.number;
-    path: (property: TPropertyValue) => {
-        [key: number]: Date;
-    };
-} : TPrimitiveType extends Guid ? {
-    type: PrimitiveType.guid;
-    dictionaryKeyType: DictionaryPrimitiveKeyType.number;
-    path: (property: TPropertyValue) => {
-        [key: number]: Guid;
-    };
-} : TPrimitiveType extends Identity ? {
-    type: PrimitiveType.identity;
-    dictionaryKeyType: DictionaryPrimitiveKeyType.number;
-    path: (property: TPropertyValue) => {
-        [key: number]: Identity;
-    };
-} : never : never;
-export declare class PropertyValueBinding<TProperty extends PropertyDefinition<any, any, any> | PropertyValue<any, any>> {
-    value: TProperty extends PropertyDefinition<any, any, any> ? PropertyValueType<TProperty> : TProperty;
+export declare class PropertyValueBinding<TPropertyDefinition extends PropertyDefinition<any, any, any>> {
+    value: PropertyValueType<TPropertyDefinition>;
     readonly propertyBindingId: GuidValue;
-    readonly propertyBindingTypeName: string;
-    readonly propertyDefinitionId: GuidValue;
-    constructor(propertyBinding: TProperty extends PropertyDefinition<any, any, any> ? PropertyBinding<TProperty> : GuidValue, value: TProperty extends PropertyDefinition<any, any, any> ? PropertyValueType<TProperty> : TProperty);
+    constructor(//definition: { new(): TPropertyDefinition ;},
+    propertyBinding: PropertyBinding<TPropertyDefinition>, value: PropertyValueType<TPropertyDefinition>);
 }
-export declare abstract class PropertyValue<TPropertyValue extends PropertyValue<any, any>, TPrimitive> {
+export declare abstract class PropertyValue {
+    containValue?(other: PropertyValue): boolean;
+    appendValue?(other: PropertyValue): PropertyValue;
 }

package/properties/PropertyValue.js

@@ -1,35 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PropertyValue = exports.PropertyValueBinding = exports.DictionaryPrimitiveKeyType = exports.PrimitiveType = void 0;
-var PrimitiveType;
-(function (PrimitiveType) {
-    PrimitiveType[PrimitiveType["none"] = 0] = "none";
-    PrimitiveType[PrimitiveType["number"] = 1] = "number";
-    PrimitiveType[PrimitiveType["string"] = 2] = "string";
-    PrimitiveType[PrimitiveType["dateTime"] = 3] = "dateTime";
-    PrimitiveType[PrimitiveType["guid"] = 4] = "guid";
-    PrimitiveType[PrimitiveType["boolean"] = 5] = "boolean";
-    PrimitiveType[PrimitiveType["multilingualString"] = 6] = "multilingualString";
-    PrimitiveType[PrimitiveType["identity"] = 7] = "identity";
-})(PrimitiveType = exports.PrimitiveType || (exports.PrimitiveType = {}));
-var DictionaryPrimitiveKeyType;
-(function (DictionaryPrimitiveKeyType) {
-    DictionaryPrimitiveKeyType[DictionaryPrimitiveKeyType["string"] = 1] = "string";
-    DictionaryPrimitiveKeyType[DictionaryPrimitiveKeyType["number"] = 2] = "number";
-})(DictionaryPrimitiveKeyType = exports.DictionaryPrimitiveKeyType || (exports.DictionaryPrimitiveKeyType = {}));
+exports.PropertyValue = exports.PropertyValueBinding = void 0;
 class PropertyValueBinding {
-    constructor(propertyBinding, value) {
+    constructor(//definition: { new(): TPropertyDefinition ;},
+    propertyBinding, value) {
         this.value = value;
-        if (propertyBinding.bindingId) {
-            this.propertyBindingId = propertyBinding.bindingId;
-            this.propertyDefinitionId = propertyBinding.propertyDefinitionId;
-        }
-        else {
-            this.propertyBindingId = propertyBinding;
-        }
+        //let defId = new definition().id;
+        this.propertyBindingId = propertyBinding.bindingId;
+        //let bindingDefId = this.propertyBindingId = (propertyBinding as PropertyBinding<any>).propertyDefinitionId
+        //if (defId !== (propertyBinding as PropertyBinding<any>).propertyDefinitionId) {
+        //    throw new Error('The binding wih id: ' + this.propertyBindingId + ' does not belong to the specifed definition id: ' + defId + ' binding definition id: ' + bindingDefId);
+        //}
     }
 }
 exports.PropertyValueBinding = PropertyValueBinding;
 class PropertyValue {
+    containValue(other) {
+        return JSON.stringify(other) == JSON.stringify(this);
+    }
+    appendValue(other) {
+        //Replace to the new value if the property isn't a term set property
+        return this;
+    }
 }
 exports.PropertyValue = PropertyValue;

package/properties/PropertyValuePrimitiveConverter.d.ts

@@ -0,0 +1,4 @@
+import { PropertyValue } from "@omnia/fx-models";
+export declare abstract class PropertyValuePrimitiveConverter {
+    abstract toPrimitiveString(propertyValue: PropertyValue): string;
+}

package/properties/PropertyValuePrimitiveConverter.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PropertyValuePrimitiveConverter = void 0;
+class PropertyValuePrimitiveConverter {
+}
+exports.PropertyValuePrimitiveConverter = PropertyValuePrimitiveConverter;

package/properties/bindingprovider/IPropertyBindingProvider.d.ts

@@ -0,0 +1,12 @@
+import { PropertyBinding, PropertyBindingId, PropertyBindingProviderId } from "../PropertyBinding";
+import { PropertyConfiguration, PropertyDefinition, PropertyValue } from "..";
+export interface IPropertyBindingProvider {
+    id: PropertyBindingProviderId;
+    getBindingById(bindingId: PropertyBindingId): Promise<PropertyBinding<PropertyDefinition<any, any, any>>>;
+    getBindings(): Promise<Array<PropertyBinding<PropertyDefinition<PropertyValue, any, any>>>>;
+    getConfiguration<TPropertyDefintion extends PropertyDefinition<any, any, any>>(binding: PropertyBinding<TPropertyDefintion>): Promise<PropertyConfiguration<TPropertyDefintion>>;
+}
+export interface ProviderBinding {
+    provider: IPropertyBindingProvider;
+    binding: PropertyBinding<PropertyDefinition<PropertyValue, any, any>>;
+}

package/properties/bindingprovider/IPropertyBindingProvider.js

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

package/properties/bindingprovider/index.d.ts

@@ -0,0 +1 @@
+export * from "./IPropertyBindingProvider";

package/properties/bindingprovider/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./IPropertyBindingProvider"), exports);

package/properties/datasource/DataSourceId.d.ts

@@ -0,0 +1,2 @@
+import { GuidValue } from "@omnia/fx-models/internal-do-not-import-from-here/shared/models/Guid";
+export type PropertyDataSourceId = GuidValue;

package/properties/datasource/DataSourceId.js

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

package/properties/datasource/DataSourceProperty.d.ts

@@ -0,0 +1,6 @@
+import { PropertyDataSourceId } from "./DataSourceId";
+export declare abstract class DataSourceProperty {
+    readonly dataSourceId: PropertyDataSourceId;
+    abstract isEqual: (property: DataSourceProperty) => boolean;
+    constructor(dataSourceId: PropertyDataSourceId);
+}

package/properties/datasource/DataSourceProperty.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataSourceProperty = void 0;
+class DataSourceProperty {
+    constructor(dataSourceId) {
+        this.dataSourceId = dataSourceId;
+    }
+}
+exports.DataSourceProperty = DataSourceProperty;

package/properties/datasource/DataSourcePropertyDisplayInformation.d.ts

@@ -0,0 +1,14 @@
+import { GuidValue } from "@omnia/fx-models/internal-do-not-import-from-here/shared/models/Guid";
+import { MultilingualString } from "../../MultilingualString";
+export declare class DataSourcePropertyCategory {
+    id: GuidValue;
+    title: MultilingualString;
+    order: number;
+    builtIn: boolean;
+    constructor(id: GuidValue, title: MultilingualString, order: number, builtIn: boolean);
+}
+export declare class DataSourcePropertyDisplayInformation {
+    title: string;
+    category?: DataSourcePropertyCategory;
+    constructor(title: string, category?: DataSourcePropertyCategory);
+}

package/properties/datasource/DataSourcePropertyDisplayInformation.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataSourcePropertyDisplayInformation = exports.DataSourcePropertyCategory = void 0;
+class DataSourcePropertyCategory {
+    constructor(id, title, order, builtIn) {
+        this.id = id;
+        this.title = title;
+        this.order = order;
+        this.builtIn = builtIn;
+    }
+}
+exports.DataSourcePropertyCategory = DataSourcePropertyCategory;
+class DataSourcePropertyDisplayInformation {
+    constructor(title, category) {
+        this.title = title;
+        this.category = category;
+    }
+}
+exports.DataSourcePropertyDisplayInformation = DataSourcePropertyDisplayInformation;

package/properties/datasource/UserDataSourceProperty.d.ts

@@ -0,0 +1,12 @@
+import { GuidValue } from "@omnia/fx-models/internal-do-not-import-from-here/shared/models/Guid";
+import { PropertyBindingId } from "../PropertyBinding";
+import { PropertyDataSourceId } from "./DataSourceId";
+import { DataSourceProperty } from "./DataSourceProperty";
+export declare class UserDataSourceProperty extends DataSourceProperty {
+    readonly enterprisePropertyBindingId?: PropertyBindingId;
+    readonly userPropertyBindingId?: PropertyBindingId;
+    readonly builtInId?: GuidValue;
+    readonly builtInInternalName?: string;
+    constructor(dataSourceId: PropertyDataSourceId, enterprisePropertyBindingId?: PropertyBindingId, userPropertyBindingId?: PropertyBindingId, builtInId?: GuidValue, builtInInternalName?: string);
+    isEqual: (property: UserDataSourceProperty) => boolean;
+}

package/properties/datasource/UserDataSourceProperty.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserDataSourceProperty = void 0;
+const DataSourceProperty_1 = require("./DataSourceProperty");
+class UserDataSourceProperty extends DataSourceProperty_1.DataSourceProperty {
+    constructor(dataSourceId, enterprisePropertyBindingId, userPropertyBindingId, builtInId, builtInInternalName) {
+        super(dataSourceId);
+        this.enterprisePropertyBindingId = enterprisePropertyBindingId;
+        this.userPropertyBindingId = userPropertyBindingId;
+        this.builtInId = builtInId;
+        this.builtInInternalName = builtInInternalName;
+        this.isEqual = (property) => {
+            return this.dataSourceId == property.dataSourceId &&
+                this.enterprisePropertyBindingId == property.enterprisePropertyBindingId &&
+                this.userPropertyBindingId == property.userPropertyBindingId &&
+                this.builtInInternalName == property.builtInInternalName;
+        };
+    }
+}
+exports.UserDataSourceProperty = UserDataSourceProperty;

package/properties/datasource/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./DataSourceProperty";
+export * from "./DataSourceId";
+export * from "./DataSourcePropertyDisplayInformation";
+export * from "./UserDataSourceProperty";

package/properties/datasource/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./DataSourceProperty"), exports);
+tslib_1.__exportStar(require("./DataSourceId"), exports);
+tslib_1.__exportStar(require("./DataSourcePropertyDisplayInformation"), exports);
+tslib_1.__exportStar(require("./UserDataSourceProperty"), exports);

package/properties/definitions/BirthdayPropertyDefinition.d.ts

@@ -0,0 +1,16 @@
+import { Guid } from "@omnia/fx-models/internal-do-not-import-from-here/shared/models";
+import { LockStatusExcludeChildren, PropertyLockStatusType } from "../../../ux";
+import { PropertyDefinition, PropertyDisplaySettingsBase, PropertyEditorSettingsBase } from "../PropertyDefinition";
+import { BirthdayPropertyValue } from "../values";
+export declare class BirthdayDisplaySettings extends PropertyDisplaySettingsBase {
+    locks?: PropertyLockStatusType<LockStatusExcludeChildren<Omit<BirthdayDisplaySettings, "locks">, "label">>;
+    fontSize?: number;
+    format?: string;
+    showIcon?: boolean;
+}
+export declare class BirthdayEditorSettings extends PropertyEditorSettingsBase {
+}
+export declare class BirthdayPropertyDefinition extends PropertyDefinition<BirthdayPropertyValue, BirthdayDisplaySettings, BirthdayEditorSettings> {
+    id: Guid;
+    typeName: string;
+}

package/properties/definitions/BirthdayPropertyDefinition.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BirthdayPropertyDefinition = exports.BirthdayEditorSettings = exports.BirthdayDisplaySettings = void 0;
+const models_1 = require("@omnia/fx-models/internal-do-not-import-from-here/shared/models");
+const PropertyDefinition_1 = require("../PropertyDefinition");
+class BirthdayDisplaySettings extends PropertyDefinition_1.PropertyDisplaySettingsBase {
+}
+exports.BirthdayDisplaySettings = BirthdayDisplaySettings;
+class BirthdayEditorSettings extends PropertyDefinition_1.PropertyEditorSettingsBase {
+}
+exports.BirthdayEditorSettings = BirthdayEditorSettings;
+class BirthdayPropertyDefinition extends PropertyDefinition_1.PropertyDefinition {
+    constructor() {
+        super(...arguments);
+        this.id = new models_1.Guid("17c2b563-94d1-4912-a786-5f33e7c1d892");
+        this.typeName = "$Localize:Omnia.Ux.Properties.Definitions.Birthday;";
+    }
+}
+exports.BirthdayPropertyDefinition = BirthdayPropertyDefinition;

package/properties/definitions/BooleanPropertyDefinition.d.ts

@@ -0,0 +1,12 @@
+import { Guid } from "@omnia/fx-models/internal-do-not-import-from-here/shared/models";
+import { PropertyDefinition, PropertyDisplaySettingsBase, PropertyEditorSettingsBase } from "../PropertyDefinition";
+import { BooleanPropertyValue } from "../values";
+export declare class BooleanDisplaySettings extends PropertyDisplaySettingsBase {
+    inline?: boolean;
+}
+export declare class BooleanEditorSettings extends PropertyEditorSettingsBase {
+}
+export declare class BooleanPropertyDefinition extends PropertyDefinition<BooleanPropertyValue, BooleanDisplaySettings, BooleanEditorSettings> {
+    id: Guid;
+    typeName: string;
+}