@omnia/fx 8.0.28-vnext → 8.0.30-vnext

package/internal-do-not-import-from-here/services/properties/datasource/DataSourcePropertyDefinitionHandler.d.ts

@@ -0,0 +1,35 @@
+import { DataSourceProperty, GuidValue, PropertyConfiguration, PropertyDefinition, PropertyValueType, PropertyDefinitionId } from "../../../models";
+export type DataSourcePropertyDefintionHandlerId = GuidValue;
+/**
+ *
+ * A plugin module for handling the different property definitions/values that can be created from the data source properties
+ *
+ * */
+export declare abstract class DataSourcePropertyDefinitionHandler<TPropertyDefinition extends PropertyDefinition<any, any, any>, TDataSourceProperty extends DataSourceProperty, DataSourceReadDataType, DataSourceWriteBackType> {
+    /**
+     * A unique constant id for this converter
+     * */
+    abstract readonly Id: DataSourcePropertyDefintionHandlerId;
+    /**
+     * Handler title, will be used if more than one handler exists for any given propertyDefinition
+     * E.g "Ticks to DateTimeProperty", and one other handler nemed "String to DateTimeProperty", i.e "TDataSourceData To TPropertyDefinition" or so.
+     * */
+    abstract readonly title: string;
+    /**
+     * The property defintion this handler is intended to handle
+     * */
+    readonly propertyDefintionId: PropertyDefinitionId;
+    /**
+     * The ctor for the definition which this handler is defined for, only used to link with definitionId in a typesafe way
+     * */
+    constructor(propertyDefinitionCtor: new () => TPropertyDefinition);
+    propertyConfiguration?: PropertyConfiguration<TPropertyDefinition>;
+    /**
+     * This method should convert from the data source value to PropertyValue matching the TPropertyDefinition
+     * */
+    abstract propertyValueCreator(dataSourceProperty: TDataSourceProperty, valueFromSource: DataSourceReadDataType): Promise<PropertyValueType<TPropertyDefinition>>;
+    /**
+     * This method should convert from PropertyValue matching the TPropertyDefinition to the write back data type expected for data source to be able to writeback
+     * */
+    abstract propertyWriteBackDataCreator(dataSourceProperty: TDataSourceProperty, propertyValue: PropertyValueType<TPropertyDefinition>): Promise<DataSourceWriteBackType>;
+}

package/internal-do-not-import-from-here/services/properties/datasource/DataSourcePropertyProvider.d.ts

@@ -0,0 +1,49 @@
+import { DataSourceProperty, DataSourcePropertyDisplayInformation, PropertyConfiguration, PropertyDataSourceId, PropertyDefinition, PropertyDefinitionId, UserIdentity } from "../../../models";
+import { WritebackResult } from "./DataSourcePropertiesService";
+export interface IDataSourcePropertyCreator {
+    createPropertyFromString(propertyName: string): Promise<DataSourceProperty>;
+}
+export declare abstract class PropertyDataSourceBase<TDataSourceProperty extends DataSourceProperty> {
+    readonly currentUser: UserIdentity;
+    readonly isImpersonatedUser: boolean;
+    abstract readonly title: string;
+    abstract readonly id: PropertyDataSourceId;
+    abstract supportsWriteback2(properties: Array<TDataSourceProperty>): Promise<Array<{
+        property: TDataSourceProperty;
+        supportsWriteBack: boolean;
+    }>>;
+    abstract writeback(properties: Array<{
+        dataSourceProperty: TDataSourceProperty;
+        valueToWriteback: any;
+    }>): Promise<Array<WritebackResult>>;
+    /**
+     * Get the current display information for a data source property, this is resolved from a data source property, as this information migth relay on system/source data that change over time
+     * */
+    abstract getPropertyDisplayInformation(dataSourceProperties: Array<TDataSourceProperty>): Promise<Array<{
+        property: TDataSourceProperty;
+        displayInformation: DataSourcePropertyDisplayInformation;
+    }>>;
+    /**
+     * Get all the properties supported by this data source, this is the @type {TDataSourceProperty} is extended to represent the information within a data source to identify a data source property
+     * */
+    abstract getProperties(): Promise<Array<TDataSourceProperty>>;
+    /**
+     * Returns the property configuration that should be used when representing this property, if the propertyconfiguration is not know by the source return null
+     * */
+    abstract getPropertyConfiguration(property: TDataSourceProperty): Promise<PropertyConfiguration<PropertyDefinition<any, any, any>>>;
+    /**
+     * Returns the property definition id that should be used for representing this property, if the propertydefinition is not know by the source return undefined, selection among source property creators can be made explicitly
+     * */
+    abstract getPropertyDefinition(property: TDataSourceProperty): Promise<PropertyDefinitionId>;
+    /**
+     * Get the value for datasource properties, the returned data type TDataSourceData must have a matching DataSourcePropertyDefinitionHandler<any,any,TDataSourceData>
+     * I.e. so a handler exists that can create property values from the source value type
+     * */
+    abstract getPropertyValues(properties: Array<TDataSourceProperty>): Promise<Array<{
+        valueFromSource: any;
+        dataSourceProperty: TDataSourceProperty;
+    }>>;
+}
+export declare abstract class DynamicPropertyDataSource<TDataSourceProperty extends DataSourceProperty> extends PropertyDataSourceBase<TDataSourceProperty> implements IDataSourcePropertyCreator {
+    abstract createPropertyFromString(propertyName: string): Promise<DataSourceProperty>;
+}

package/internal-do-not-import-from-here/services/properties/datasource/TestDataSourceService.d.ts

@@ -0,0 +1,6 @@
+import { DataSourcePropertiesService } from "./DataSourcePropertiesService";
+export declare class TestDataSourcePropertiesService {
+    dataSourcePropertiesService: DataSourcePropertiesService;
+    constructor();
+    runTest(): Promise<void>;
+}

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

@@ -0,0 +1,4 @@
+export * from "./DataSourcePropertyProvider";
+export * from "./DataSourcePropertyDefinitionHandler";
+export * from "./DataSourcePropertiesService";
+export * from "./TestDataSourceService";

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

@@ -0,0 +1,3 @@
+export * from "./bindings";
+export * from "./datasource";
+export * from "./EnterprisePropertiesProvider";

package/internal-do-not-import-from-here/shared/models/theming/BlueprintDefinition.d.ts

@@ -19,9 +19,11 @@ export declare enum WebBlueprintDefintionTypes {
     block = "block",
     typography = "typography"
 }
-export type VelcronBlueprintDefintionType = "button";
+export type VelcronBlueprintDefintionType = "button" | "typography";
 export declare enum VelcronBlueprintDefintionTypes {
-    button = "button"
+    button = "button",
+    block = "block",
+    typography = "typography"
 }
 export interface BlueprintItemDefinition {
     type: any;

package/internal-do-not-import-from-here/shared/models/theming/BlueprintDefinition.js

@@ -10,4 +10,6 @@ var WebBlueprintDefintionTypes;
 var VelcronBlueprintDefintionTypes;
 (function (VelcronBlueprintDefintionTypes) {
     VelcronBlueprintDefintionTypes["button"] = "button";
+    VelcronBlueprintDefintionTypes["block"] = "block";
+    VelcronBlueprintDefintionTypes["typography"] = "typography";
 })(VelcronBlueprintDefintionTypes = exports.VelcronBlueprintDefintionTypes || (exports.VelcronBlueprintDefintionTypes = {}));

package/internal-do-not-import-from-here/stores/EnterprisePropertyStore.d.ts

@@ -13,7 +13,7 @@ export declare class EnterprisePropertyStore extends Store {
     enterprisePropertyDefinitions: import("./Store").StoreState<EnterprisePropertyDefinition[]>;
     enterprisePropertyDataTypes: import("./Store").StoreState<EnterprisePropertyDataType[]>;
     computedPropertyMapping: import("./Store").StoreState<{
-        [serviceIdKey: string]: EnterprisePropertyColumnMapping[];
+        [serviceIdWithTableKey: string]: EnterprisePropertyColumnMapping[];
     }>;
     getters: {
         enterprisePropertyDefinitionsByIndexedTypes: (indexTypes: Array<PropertyIndexedType>) => EnterprisePropertyDefinition[];
@@ -42,7 +42,7 @@ export declare class EnterprisePropertyStore extends Store {
     };
     actions: {
         refresh: import("./Store").StoreAction<unknown, () => void, (result: boolean) => void, (failureReason: any) => void, () => Promise<boolean>>;
-        ensureLoadData: import("./Store").StoreAction<unknown, () => void, (result: boolean) => void, (failureReason: any) => void, () => Promise<boolean>>;
+        ensureLoadData: import("./Store").StoreAction<unknown, (forceReload?: boolean) => void, (result: boolean, forceReload?: boolean) => void, (failureReason: any, forceReload?: boolean) => void, (forceReload?: boolean) => Promise<boolean>>;
         addEnterprisePropertyDefinition: import("./Store").StoreAction<unknown, (enterpriseProperty: EnterprisePropertyDefinition) => void, (result: EnterprisePropertyDefinition, enterpriseProperty: EnterprisePropertyDefinition) => void, (failureReason: any, enterpriseProperty: EnterprisePropertyDefinition) => void, (enterpriseProperty: EnterprisePropertyDefinition) => Promise<EnterprisePropertyDefinition>>;
         updateEnterprisePropertyDefinition: import("./Store").StoreAction<unknown, (enterpriseProperty: EnterprisePropertyDefinition) => void, (result: EnterprisePropertyDefinition, enterpriseProperty: EnterprisePropertyDefinition) => void, (failureReason: any, enterpriseProperty: EnterprisePropertyDefinition) => void, (enterpriseProperty: EnterprisePropertyDefinition) => Promise<EnterprisePropertyDefinition>>;
         removeEnterprisePropertyDefinition: import("./Store").StoreAction<unknown, (enterprisePropertyId: GuidValue) => void, (result: boolean, enterprisePropertyId: GuidValue) => void, (failureReason: any, enterprisePropertyId: GuidValue) => void, (enterprisePropertyId: GuidValue) => Promise<boolean>>;
@@ -54,6 +54,7 @@ export declare class EnterprisePropertyStore extends Store {
         addQueryableProperties: import("./Store").StoreAction<unknown, (serviceId: GuidValue, properties: EnterprisePropertyColumnMapping[]) => void, (result: void, serviceId: GuidValue, properties: EnterprisePropertyColumnMapping[]) => void, (failureReason: any, serviceId: GuidValue, properties: EnterprisePropertyColumnMapping[]) => void, (serviceId: GuidValue, properties: EnterprisePropertyColumnMapping[]) => Promise<void>>;
     };
     private ensureUniqueMultilingualTitle;
+    private getServiceIdWithTableKey;
     onActivated(): void;
     onDisposing(): void;
 }

package/internal-do-not-import-from-here/stores/FeatureStore.d.ts

@@ -35,6 +35,7 @@ export declare class FeatureStore extends Store {
         }) => Promise<FeatureInstance[]>>;
         loadFeatureInstance: import("./Store").StoreAction<unknown, (featureId: GuidValue) => void, (result: FeatureInstance, featureId: GuidValue) => void, (failureReason: any, featureId: GuidValue) => void, (featureId: GuidValue) => Promise<FeatureInstance>>;
         activateFeature: import("./Store").StoreAction<unknown, (featureId: GuidValue, properties: any) => void, (result: FeatureInstance, featureId: GuidValue, properties: any) => void, (failureReason: any, featureId: GuidValue, properties: any) => void, (featureId: GuidValue, properties: any) => Promise<FeatureInstance>>;
+        requestConsent: import("./Store").StoreAction<unknown, (featureIds: GuidValue[]) => void, (result: FeatureInstance[], featureIds: GuidValue[]) => void, (failureReason: any, featureIds: GuidValue[]) => void, (featureIds: GuidValue[]) => Promise<FeatureInstance[]>>;
         upgradeFeature: import("./Store").StoreAction<unknown, (featureId: GuidValue, properties: any) => void, (result: FeatureInstance, featureId: GuidValue, properties: any) => void, (failureReason: any, featureId: GuidValue, properties: any) => void, (featureId: GuidValue, properties: any) => Promise<FeatureInstance>>;
         removeFeature: import("./Store").StoreAction<unknown, (featureId: GuidValue) => void, (result: FeatureInstance, featureId: GuidValue) => void, (failureReason: any, featureId: GuidValue) => void, (featureId: GuidValue) => Promise<FeatureInstance>>;
     };

package/internal-do-not-import-from-here/stores/IdentityStore.d.ts

@@ -1,4 +1,4 @@
-import { Future, Identity, IdentityQuery, IResolvedIdentity } from "@omnia/fx-models";
+import { Future, Identity, IdentityQuery, IResolvedIdentity } from "../models";
 import { Store } from "./Store";
 export declare class IdentityStore extends Store {
     private identityService;

package/internal-do-not-import-from-here/stores/IdentitySyncProviderStore.d.ts

@@ -13,6 +13,7 @@ export declare class IdentitySyncProviderStore extends Store {
             ended?: Date;
             status: import("@omnia/fx-models").IdentityProviderRunStatus;
             fullSyncOnNextRun: boolean;
+            fullUserSyncOnNextRun: boolean;
             fullLogOnNextRun: boolean;
             togglePauseOnNextRun: boolean;
             setupComplete: boolean;

package/internal-do-not-import-from-here/stores/UserIdentityStore.d.ts

@@ -1,4 +1,4 @@
-import { GroupIdentity, IdentityPropertyBinding, IdentityProperty, ResolvedUserIdentity, UserIdentity } from "@omnia/fx-models";
+import { EnterprisePropertyDefinition, GroupIdentity, GuidValue, Identity, IdentityProperty, PropertyBinding, PropertyDefinition, ResolvedUserIdentity, UserIdentity } from "@omnia/fx-models";
 import { MediaPickerService, UserPresenceStatus } from "../services";
 import { Store } from "./Store";
 export declare class UserIdentityStore extends Store {
@@ -21,7 +21,8 @@ export declare class UserIdentityStore extends Store {
         getUserImageUrl: (user: ResolvedUserIdentity, imageRatioId?: number, scalingId?: number) => string;
     };
     actions: {
-        addUserProperty: import("./Store").StoreAction<unknown, (property: IdentityPropertyBinding<import("@omnia/fx-models").PropertyDefinition<any, any, any>>) => void, (result: void, property: IdentityPropertyBinding<import("@omnia/fx-models").PropertyDefinition<any, any, any>>) => void, (failureReason: any, property: IdentityPropertyBinding<import("@omnia/fx-models").PropertyDefinition<any, any, any>>) => void, (property: IdentityPropertyBinding) => Promise<void>>;
+        addUserProperty: import("./Store").StoreAction<unknown, (property: PropertyBinding<PropertyDefinition<any, any, any, import("@omnia/fx-models").PropertySetupBase>>) => void, (result: void, property: PropertyBinding<PropertyDefinition<any, any, any, import("@omnia/fx-models").PropertySetupBase>>) => void, (failureReason: any, property: PropertyBinding<PropertyDefinition<any, any, any, import("@omnia/fx-models").PropertySetupBase>>) => void, (property: PropertyBinding<PropertyDefinition<any, any, any>>) => Promise<void>>;
+        createUserProperty: import("./Store").StoreAction<unknown, (property: EnterprisePropertyDefinition) => void, (result: void, property: EnterprisePropertyDefinition) => void, (failureReason: any, property: EnterprisePropertyDefinition) => void, (property: EnterprisePropertyDefinition) => Promise<void>>;
         removeUserProperty: import("./Store").StoreAction<unknown, (identityProperty: IdentityProperty) => void, (result: void, identityProperty: IdentityProperty) => void, (failureReason: any, identityProperty: IdentityProperty) => void, (identityProperty: IdentityProperty) => Promise<void>>;
         ensureLoadUserProperties: import("./Store").StoreAction<unknown, () => void, (result: IdentityProperty[]) => void, (failureReason: any) => void, () => Promise<IdentityProperty[]>>;
         resolveUsersIdentity: import("./Store").StoreAction<unknown, (users: UserIdentity[]) => void, (result: {
@@ -50,6 +51,11 @@ export declare class UserIdentityStore extends Store {
             [groupUid: string]: boolean;
         }>>;
         getUserGroups: import("./Store").StoreAction<unknown, (user: UserIdentity) => void, (result: GroupIdentity[], user: UserIdentity) => void, (failureReason: any, user: UserIdentity) => void, (user: UserIdentity) => Promise<GroupIdentity[]>>;
+        getIdentitiesWithProviderIdentities: import("./Store").StoreAction<unknown, (providerId: GuidValue, userIds: GuidValue[]) => void, (result: {
+            [userIdentityUid: string]: Identity;
+        }, providerId: GuidValue, userIds: GuidValue[]) => void, (failureReason: any, providerId: GuidValue, userIds: GuidValue[]) => void, (providerId: GuidValue, userIds: GuidValue[]) => Promise<{
+            [userIdentityUid: string]: Identity;
+        }>>;
     };
     protected onActivated(): void;
 }

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

@@ -3,5 +3,6 @@ export declare class AppRollupFilterEngineContext extends DbQueryFilterEngineCon
     componentId: string;
     uniqueId: string;
     constructor(componentId: string);
+    readonly supportFullTextSearch: boolean;
     getAvailableProperties(): import("@omnia/fx-models").EnterprisePropertyDefinition[];
 }

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

@@ -72,6 +72,8 @@ export * from "./AnchorLink";
 export * from "./LayoutFileContext";
 export * from "./AppRollupFilterEngineContext";
 export * from "./SidePanelContext";
+export * from "./ScrollHelper";
+export * from "./ListViewComponentBase";
 export { OmniaTheming } from "./OmniaTheming";
 export type { FocusOption, ClickOutOption, ScrollOption, LinkHandlerOptions, } from "./directives";
 export { FocusDirective, ClickOutDirective, ScrollDirective, LinkHandlerDirective, } from "./directives";

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

@@ -0,0 +1,6 @@
+import { VueComponentBase } from "./VueComponentBase";
+export declare class ListViewComponentBase extends VueComponentBase {
+    constructor();
+    created(): void;
+    mounted(): void;
+}

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

@@ -0,0 +1,28 @@
+export declare class StickyElementHelper {
+    constructor();
+    private blockElement;
+    private componentElm;
+    private stickyElmScrollableParent;
+    private scrollCallback;
+    private parentScrollOffset;
+    private lastScrollTop;
+    private paddingTop;
+    private isSticky;
+    private selector;
+    private elementWidth;
+    private bgColor;
+    private previousStyle;
+    private previousColumnStyle;
+    private static FILTER_CLASS;
+    private tableColumnWidth;
+    private applyStickyStyle;
+    private tableColumnStyle;
+    private stickyMenu;
+    private tableColumn;
+    registerStickyElement(componentElm: Element, selector: string): void;
+    checkSticky(elm: Element): void;
+    private getTopFilterHeight;
+    private getTableColumnWidth;
+    private getStickyElement;
+    getBackground(element: any): any;
+}

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

@@ -1,4 +1,5 @@
-export declare class SidePanelContext {
-    forceShowAsDialog: boolean;
-    forceAvoidLeftMegaMenu: boolean;
+import { ISidePanelContext } from "../models";
+export declare class SidePanelContext implements ISidePanelContext {
+    leftPositionDisabled: boolean;
+    rightPositionDisabled: boolean;
 }

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

@@ -34,6 +34,7 @@ export interface OmniaUxLocalization {
         };
         Yes: string;
         No: string;
+        NotApplicable: string;
         Default: string;
         Type: string;
         Text: string;
@@ -277,7 +278,7 @@ export interface OmniaUxLocalization {
                     Subject: string;
                     Body: string;
                 };
-                OnBoarding: {
+                OnBoardingLink: {
                     Subject: string;
                     Body: string;
                 };
@@ -406,14 +407,19 @@ export interface OmniaUxLocalization {
         IncludeChildTerms: string;
         IncludeEmpty: string;
         AddFilter: string;
+        Settings: {
+            FixedHeader: string;
+            FixedFilterArea: string;
+        };
     };
     EnterpriseGlossary: {
         EnterpriseGlossaryPicker: string;
     };
     Properties: {
-        SelectPropertyType: string;
+        PropertyType: string;
         DataSource: string;
         SelectProperties: string;
+        PropertyTypeConverter: string;
         Definitions: {
             Birthday: string;
             Date: string;
@@ -421,9 +427,12 @@ export interface OmniaUxLocalization {
             Email: string;
             Html: string;
             Image: string;
+            Media: string;
             PhoneNumber: string;
             MultilineText: string;
             Text: string;
+            Integer: string;
+            Boolean: string;
             Link: string;
             Time: string;
             Identity: string;
@@ -457,6 +466,20 @@ export interface OmniaUxLocalization {
             PhoneNumber: {
                 InvalidPatternMessage: string;
             };
+            Media: {
+                AddMedia: string;
+            };
+            TermSet: {
+                TextOnly: string;
+                MultiValue: string;
+            };
+            InternalName: string;
+            InternalNameInvalidMessage: string;
+            Setup: string;
+            Display: string;
+            Edit: string;
+            ShowLabelText: string;
+            ShowLabelIcon: string;
         };
         ValidationErrors: {
             WhiteSpaceNotAllowed: string;
@@ -551,6 +574,7 @@ export interface OmniaUxLocalization {
         ShowTeamsPresence: {
             Category: string;
             Description: string;
+            ConsentInformation: string;
             Title: string;
         };
         SocialReactions: {
@@ -574,6 +598,12 @@ export interface OmniaUxLocalization {
             Title: string;
         };
         LegacyPre7Permissions: {
+            Category: string;
+            Description: string;
+            ConsentInformation: string;
+            Title: string;
+        };
+        LegacyUserProfileCard: {
             Category: string;
             Description: string;
             Title: string;
@@ -583,6 +613,11 @@ export interface OmniaUxLocalization {
             Description: string;
             Title: string;
         };
+        TextCompletion: {
+            Category: string;
+            Description: string;
+            Title: string;
+        };
     };
     AuditLog: {
         Title: string;
@@ -624,10 +659,12 @@ export interface OmniaUxLocalization {
         };
     };
     FilterEngine: {
+        Common: {
+            From: string;
+            To: string;
+        };
         Editor: {
             Common: {
-                From: string;
-                To: string;
                 TermSetNotFound: string;
                 DefaultPosition: {
                     Label: string;
@@ -638,6 +675,7 @@ export interface OmniaUxLocalization {
                         Dialog: string;
                     };
                 };
+                DefaultValue: string;
             };
             DialogPosition: {
                 Label: string;
@@ -649,23 +687,40 @@ export interface OmniaUxLocalization {
             GeneralTab: string;
             StyleTab: string;
             ShowSearchBox: string;
-            ShowSortDropdown: string;
+            SearchBoxSettings: {
+                Mode: {
+                    Label: string;
+                    Properties: string;
+                    FullText: string;
+                };
+                DefaultSearchText: string;
+                SearchTitleAnd: string;
+                SearchProperties: string;
+            };
             Property: {
                 UserFilterOption: {
+                    NoDefault: string;
                     CurrentUser: string;
                     PickedUser: string;
                 };
-                BooleanFilterOption: {
-                    Yes: string;
-                    No: string;
-                };
                 FilterRenderType: {
                     Label: string;
                     Option: {
-                        Dropdown: string;
-                        List: string;
-                        Tags: string;
-                        IconButtons: string;
+                        Dropdown: {
+                            Label: string;
+                        };
+                        List: {
+                            Label: string;
+                            CollapsedByDefault: string;
+                            DefaultVisibleItems: string;
+                        };
+                        Tags: {
+                            Label: string;
+                        };
+                        IconButtons: {
+                            Label: string;
+                            DefaultVisibleItems: string;
+                        };
                     };
                 };
                 Operator: {
@@ -687,32 +742,43 @@ export interface OmniaUxLocalization {
                 ShowEnterpriseGlossaryIcon: string;
                 ShowResultCount: string;
                 ShowZeroResultCountValues: string;
-                DefaultVisibleIconButtons: string;
                 IconButtonsWidth: string;
             };
             AddFilter: string;
             SaveFilterState: string;
             RunQueryOnLoad: string;
             ShowSelectedValuesArea: string;
+            FixedFilter: string;
             ShowPropertyLabel: string;
             MaxVisibleValues: string;
             FilterWidth: string;
+            FixedFilterWidth: string;
             GeneralStyleLabel: string;
             OutlinedStyle: string;
             RoundedStyle: string;
             FilledStyle: string;
             ChipColorsLabel: string;
+            DefaultChipColor: string;
             EnterpriseGlossaryChipColor: string;
-            CustomChipColor: string;
+            CustomChipColor: {
+                Label: string;
+                Colors: {
+                    Background: string;
+                    Text: string;
+                };
+            };
+            SearchBoxWidth: string;
         };
         Renderer: {
             Common: {
                 Title: string;
                 ShowMore: string;
                 ShowLess: string;
+                Clear: string;
             };
             TermPicker: {
                 ClearAllButton: string;
+                FindTerm: string;
             };
             SearchValueBox: {
                 Label: string;
@@ -1122,6 +1188,24 @@ export interface OmniaUxLocalization {
         Title: string;
         Decsription: string;
     };
+    IdentityPicker: {
+        User: {
+            Searchbox: {
+                Placeholder: string;
+            };
+            Type: {
+                Label: string;
+            };
+        };
+        Group: {
+            Searchbox: {
+                Placeholder: string;
+            };
+            Type: {
+                Label: string;
+            };
+        };
+    };
 }
 export declare const OmniaUxLocalizationNamespace = "Omnia.Ux";
 export declare const BuiltInLocalizationKeys: {

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

@@ -1,25 +1,37 @@
-import { DataSourcePropertyBinding, Guid, PropertyBinding, PropertyConfiguration, PropertyDefinition, PropertyValueBinding } from "@omnia/fx-models";
-import { LegacyEnterprisePropertiesProvider, PropertyDataSourceBase } from "..";
+import { DataSourceProperty, Guid, PropertyConfiguration, PropertyDefinition, PropertyDataSourceId, DataSourcePropertyDisplayInformation, GuidValue, PropertyDefinitionId } from "@omnia/fx-models";
 import { EnterprisePropertyStore, MultilingualStore } from "@omnia/fx/stores";
-import { LocalizationService } from "@omnia/fx/services";
-export declare class AppPropertiesProvider extends PropertyDataSourceBase {
+import { LocalizationService, EnterprisePropertiesProvider, PropertyDataSourceBase, WritebackResult } from "@omnia/fx/services";
+export declare class AppDataSourceProperty extends DataSourceProperty {
+    readonly enterprisePropertyDefinitionId?: GuidValue;
+    readonly builtInInternalName?: string;
+    constructor(dataSourceId: PropertyDataSourceId, enterprisePropertyDefinitionId?: GuidValue, builtInInternalName?: string);
+}
+export declare class AppPropertiesProvider extends PropertyDataSourceBase<AppDataSourceProperty> {
     id: Guid;
     title: string;
     private omniaContext;
     enterprisePropertyStore: EnterprisePropertyStore;
     multilingualStore: MultilingualStore;
-    legacyEnterprisePropertiesProvider: LegacyEnterprisePropertiesProvider;
+    enterprisePropertiesProvider: EnterprisePropertiesProvider;
     localizationService: LocalizationService;
-    static properties: Array<DataSourcePropertyBinding>;
-    supportsWriteback(property: PropertyConfiguration<PropertyDefinition<any, any, any>>): boolean;
-    onSavePropertyValue(properties: PropertyValueBinding<PropertyDefinition<any, any, any>>[]): Promise<void>;
-    static builtInProperties: {
-        id: Guid;
-        internalName: string;
-        title: string;
-        definitionId: Guid;
-    }[];
-    getPropertyBinding(property: PropertyConfiguration<PropertyDefinition<any, any, any>>): Promise<PropertyBinding<PropertyDefinition<any, any, any>>>;
-    getProperties(): Promise<Array<DataSourcePropertyBinding>>;
-    getPropertyValue(property: PropertyConfiguration<PropertyDefinition<any, any, any>>): Promise<PropertyValueBinding<PropertyDefinition<any, any, any>>>;
+    private static builtInProperties;
+    supportsWriteback2(properties: AppDataSourceProperty[]): Promise<{
+        property: AppDataSourceProperty;
+        supportsWriteBack: boolean;
+    }[]>;
+    writeback(properties: {
+        dataSourceProperty: AppDataSourceProperty;
+        valueToWriteback: any;
+    }[]): Promise<WritebackResult[]>;
+    getPropertyConfiguration(property: AppDataSourceProperty): Promise<PropertyConfiguration<PropertyDefinition<any, any, any>>>;
+    getPropertyDefinition(property: AppDataSourceProperty): Promise<PropertyDefinitionId>;
+    getPropertyValues(properties: AppDataSourceProperty[]): Promise<Array<{
+        valueFromSource: any;
+        dataSourceProperty: AppDataSourceProperty;
+    }>>;
+    getProperties(): Promise<Array<AppDataSourceProperty>>;
+    getPropertyDisplayInformation(dataSourceProperties: AppDataSourceProperty[]): Promise<{
+        property: AppDataSourceProperty;
+        displayInformation: DataSourcePropertyDisplayInformation;
+    }[]>;
 }

package/internal-do-not-import-from-here/ux/app/appinstance/view/listing/ListView.d.ts

@@ -14,6 +14,7 @@ export declare class AppInstanceRollupListViewComponent extends AppInstanceRollu
     created(): void;
     mounted(): void;
     private init;
+    private registerStickyHeader;
     private initSpacingAndPadding;
     private renderColumn;
     private renderColumns;

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

@@ -1,2 +1,3 @@
 export * from "./Router";
 export * from "./AppContextProvider";
+export * from "./AppPropertiesProvider";

package/internal-do-not-import-from-here/ux/app/management/core/loc.d.ts

@@ -68,12 +68,15 @@ export declare module AppManagementLocalization {
                 Add: string;
                 Edit: string;
                 AddDescription: string;
+                EmptyTitleMessage: string;
                 Visible: string;
                 Hidden: string;
                 CurrentUser: string;
+                CurrentUserValue: string;
                 ToDay: string;
                 NoDefault: string;
                 Fixed: string;
+                FixedValue: string;
                 Calculated: string;
                 Yes: string;
                 No: string;

package/internal-do-not-import-from-here/ux/app/management/tabs/namingpolicies/ListingNamingPolicies.d.ts

@@ -1,7 +1,3 @@
-import { AppNamingPolicy } from "@omnia/fx-models";
-export interface FixedAppNamingPolicy extends AppNamingPolicy {
-    display: boolean;
-}
 declare const _default: {
     new (...args: any[]): {
         $: import("vue").ComponentInternalInstance;

package/internal-do-not-import-from-here/ux/app/management/tabs/templates/tabs/PropertyRow.d.ts

@@ -73,8 +73,8 @@ declare const _default: {
 }>>, () => JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
     propsDefinition: Omit<Readonly<{} & {
         property?: FixedDefaultEnterprisePropertyValue;
-        appTemplate?: AppTemplate;
         targetingProperties?: TargetingProperty<TargetingPropertyData>[];
+        appTemplate?: AppTemplate;
         defaultPropertySetValue?: {};
         templateProperties?: EnterprisePropertyItemSettings[];
         visibilitySettings?: unknown;

package/internal-do-not-import-from-here/ux/authsetup/AuthSetup.css.d.ts

@@ -4,4 +4,5 @@ export declare const AuthSetupStyles: {
     main: (breakPoint: Breakpoint) => types.NestedCSSProperties;
     container: types.NestedCSSProperties;
     passwordContainer: types.NestedCSSProperties;
+    securityText: types.NestedCSSProperties;
 };