@omnia/workplace 7.0.50-vnext → 7.0.60-dev

package/internal-do-not-import-from-here/models/Enums.d.ts

@@ -0,0 +1,129 @@
+export declare module Enums {
+    enum DocumentTypes {
+        None = 0,
+        Folder = 1,
+        File = 2
+    }
+    enum ViewType {
+        List = 0,
+        GroupedBySite = 1
+    }
+    enum IconType {
+        Sketched = 0,
+        Image = 1
+    }
+    enum SearchScope {
+        all = 0,
+        sites = 1,
+        people = 2
+    }
+    enum SearchContentTypes {
+        Site = 0,
+        Web = 1,
+        List = 2,
+        Document = 3,
+        DiscussionNewsFeedItem = 4,
+        AssetItem = 5,
+        People = 6,
+        Others = 7
+    }
+    enum SortDirection {
+        Ascending = 0,
+        Descending = 1,
+        FQLFormula = 2
+    }
+    enum SearchResultItemTypes {
+        SharePoint = 0,
+        MicrosoftSearch = 1,
+        SharedLink = 2
+    }
+    module UserProfileCompletionEnums {
+        enum PropertySourceEnum {
+            SPUserProfile = 1,
+            AzureAD = 2,
+            OmniaSystemLanguage = 3
+        }
+        enum CompletionImpactTypeEnum {
+            None = 0,
+            High = 1,
+            Medium = 2,
+            Low = 3
+        }
+        enum SPUserProfilePropertyDisplayTypeEnum {
+            ProfilePicture = 0,
+            Text = 1,
+            MultilineText = 2,
+            TermSet = 3,
+            Person = 4,
+            HtmlText = 5
+        }
+        enum AzureADPropertyDisplayTypeEnum {
+            Text = 1,
+            MultilineText = 2
+        }
+        enum OmniaSystemLanguageDisplayTypeEnum {
+            Text = 1
+        }
+    }
+    module PeopleRollupEnums {
+        enum PagingType {
+            NoPaging = 1,
+            Classic = 2,
+            Scroll = 3
+        }
+        enum BooleamFilterOption {
+            Yes = 1,
+            No = 2
+        }
+        enum RefinerOrderBy {
+            Count = 1,
+            Alphabetic = 2
+        }
+        enum Positions {
+            Top = 1,
+            Left = 2,
+            Right = 3
+        }
+        enum DateTimeMode {
+            Normal = 1,
+            Social = 2
+        }
+        enum ManagedPropertyOption {
+            Refinable = 1,
+            Retrievable = 2,
+            Sortable = 3,
+            Queryable = 4
+        }
+        enum DatePeriods {
+            NoLimit = 0,
+            OneWeekFromToday = 1,
+            TwoWeeksFromToday = 2,
+            OneMonthFromToday = 3
+        }
+        enum QueryType {
+            ProfileQuery = 0,
+            SharePointGroups = 1,
+            ActivityQuery = 2,
+            UserFieldsOnPage = 3,
+            Birthday = 4
+        }
+        enum BirthdayPeriod {
+            NoLimit = 0,
+            Today = 1,
+            OneMonthFromToday = 2
+        }
+    }
+    enum ChromeMode {
+        Full = 0,
+        Compact = 1
+    }
+    enum NavigationBarPosition {
+        Top = 0,
+        Left = 1
+    }
+    enum Alignment {
+        Left = 1,
+        Center = 2,
+        Right = 3
+    }
+}

package/internal-do-not-import-from-here/models/Enums.js

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Enums = void 0;
+var Enums;
+(function (Enums) {
+    let DocumentTypes;
+    (function (DocumentTypes) {
+        DocumentTypes[DocumentTypes["None"] = 0] = "None";
+        DocumentTypes[DocumentTypes["Folder"] = 1] = "Folder";
+        DocumentTypes[DocumentTypes["File"] = 2] = "File";
+    })(DocumentTypes = Enums.DocumentTypes || (Enums.DocumentTypes = {}));
+    let ViewType;
+    (function (ViewType) {
+        ViewType[ViewType["List"] = 0] = "List";
+        ViewType[ViewType["GroupedBySite"] = 1] = "GroupedBySite";
+    })(ViewType = Enums.ViewType || (Enums.ViewType = {}));
+    let IconType;
+    (function (IconType) {
+        IconType[IconType["Sketched"] = 0] = "Sketched";
+        IconType[IconType["Image"] = 1] = "Image";
+    })(IconType = Enums.IconType || (Enums.IconType = {}));
+    let SearchScope;
+    (function (SearchScope) {
+        SearchScope[SearchScope["all"] = 0] = "all";
+        SearchScope[SearchScope["sites"] = 1] = "sites";
+        SearchScope[SearchScope["people"] = 2] = "people";
+    })(SearchScope = Enums.SearchScope || (Enums.SearchScope = {}));
+    let SearchContentTypes;
+    (function (SearchContentTypes) {
+        SearchContentTypes[SearchContentTypes["Site"] = 0] = "Site";
+        SearchContentTypes[SearchContentTypes["Web"] = 1] = "Web";
+        SearchContentTypes[SearchContentTypes["List"] = 2] = "List";
+        SearchContentTypes[SearchContentTypes["Document"] = 3] = "Document";
+        SearchContentTypes[SearchContentTypes["DiscussionNewsFeedItem"] = 4] = "DiscussionNewsFeedItem";
+        SearchContentTypes[SearchContentTypes["AssetItem"] = 5] = "AssetItem";
+        SearchContentTypes[SearchContentTypes["People"] = 6] = "People";
+        SearchContentTypes[SearchContentTypes["Others"] = 7] = "Others";
+    })(SearchContentTypes = Enums.SearchContentTypes || (Enums.SearchContentTypes = {}));
+    let SortDirection;
+    (function (SortDirection) {
+        SortDirection[SortDirection["Ascending"] = 0] = "Ascending";
+        SortDirection[SortDirection["Descending"] = 1] = "Descending";
+        SortDirection[SortDirection["FQLFormula"] = 2] = "FQLFormula";
+    })(SortDirection = Enums.SortDirection || (Enums.SortDirection = {}));
+    let SearchResultItemTypes;
+    (function (SearchResultItemTypes) {
+        SearchResultItemTypes[SearchResultItemTypes["SharePoint"] = 0] = "SharePoint";
+        SearchResultItemTypes[SearchResultItemTypes["MicrosoftSearch"] = 1] = "MicrosoftSearch";
+        SearchResultItemTypes[SearchResultItemTypes["SharedLink"] = 2] = "SharedLink";
+    })(SearchResultItemTypes = Enums.SearchResultItemTypes || (Enums.SearchResultItemTypes = {}));
+    let UserProfileCompletionEnums;
+    (function (UserProfileCompletionEnums) {
+        let PropertySourceEnum;
+        (function (PropertySourceEnum) {
+            PropertySourceEnum[PropertySourceEnum["SPUserProfile"] = 1] = "SPUserProfile";
+            PropertySourceEnum[PropertySourceEnum["AzureAD"] = 2] = "AzureAD";
+            PropertySourceEnum[PropertySourceEnum["OmniaSystemLanguage"] = 3] = "OmniaSystemLanguage";
+        })(PropertySourceEnum = UserProfileCompletionEnums.PropertySourceEnum || (UserProfileCompletionEnums.PropertySourceEnum = {}));
+        let CompletionImpactTypeEnum;
+        (function (CompletionImpactTypeEnum) {
+            CompletionImpactTypeEnum[CompletionImpactTypeEnum["None"] = 0] = "None";
+            CompletionImpactTypeEnum[CompletionImpactTypeEnum["High"] = 1] = "High";
+            CompletionImpactTypeEnum[CompletionImpactTypeEnum["Medium"] = 2] = "Medium";
+            CompletionImpactTypeEnum[CompletionImpactTypeEnum["Low"] = 3] = "Low";
+        })(CompletionImpactTypeEnum = UserProfileCompletionEnums.CompletionImpactTypeEnum || (UserProfileCompletionEnums.CompletionImpactTypeEnum = {}));
+        let SPUserProfilePropertyDisplayTypeEnum;
+        (function (SPUserProfilePropertyDisplayTypeEnum) {
+            SPUserProfilePropertyDisplayTypeEnum[SPUserProfilePropertyDisplayTypeEnum["ProfilePicture"] = 0] = "ProfilePicture";
+            SPUserProfilePropertyDisplayTypeEnum[SPUserProfilePropertyDisplayTypeEnum["Text"] = 1] = "Text";
+            SPUserProfilePropertyDisplayTypeEnum[SPUserProfilePropertyDisplayTypeEnum["MultilineText"] = 2] = "MultilineText";
+            SPUserProfilePropertyDisplayTypeEnum[SPUserProfilePropertyDisplayTypeEnum["TermSet"] = 3] = "TermSet";
+            SPUserProfilePropertyDisplayTypeEnum[SPUserProfilePropertyDisplayTypeEnum["Person"] = 4] = "Person";
+            SPUserProfilePropertyDisplayTypeEnum[SPUserProfilePropertyDisplayTypeEnum["HtmlText"] = 5] = "HtmlText";
+        })(SPUserProfilePropertyDisplayTypeEnum = UserProfileCompletionEnums.SPUserProfilePropertyDisplayTypeEnum || (UserProfileCompletionEnums.SPUserProfilePropertyDisplayTypeEnum = {}));
+        let AzureADPropertyDisplayTypeEnum;
+        (function (AzureADPropertyDisplayTypeEnum) {
+            AzureADPropertyDisplayTypeEnum[AzureADPropertyDisplayTypeEnum["Text"] = 1] = "Text";
+            AzureADPropertyDisplayTypeEnum[AzureADPropertyDisplayTypeEnum["MultilineText"] = 2] = "MultilineText";
+        })(AzureADPropertyDisplayTypeEnum = UserProfileCompletionEnums.AzureADPropertyDisplayTypeEnum || (UserProfileCompletionEnums.AzureADPropertyDisplayTypeEnum = {}));
+        let OmniaSystemLanguageDisplayTypeEnum;
+        (function (OmniaSystemLanguageDisplayTypeEnum) {
+            OmniaSystemLanguageDisplayTypeEnum[OmniaSystemLanguageDisplayTypeEnum["Text"] = 1] = "Text";
+        })(OmniaSystemLanguageDisplayTypeEnum = UserProfileCompletionEnums.OmniaSystemLanguageDisplayTypeEnum || (UserProfileCompletionEnums.OmniaSystemLanguageDisplayTypeEnum = {}));
+    })(UserProfileCompletionEnums = Enums.UserProfileCompletionEnums || (Enums.UserProfileCompletionEnums = {}));
+    let PeopleRollupEnums;
+    (function (PeopleRollupEnums) {
+        let PagingType;
+        (function (PagingType) {
+            PagingType[PagingType["NoPaging"] = 1] = "NoPaging";
+            PagingType[PagingType["Classic"] = 2] = "Classic";
+            PagingType[PagingType["Scroll"] = 3] = "Scroll";
+        })(PagingType = PeopleRollupEnums.PagingType || (PeopleRollupEnums.PagingType = {}));
+        let BooleamFilterOption;
+        (function (BooleamFilterOption) {
+            BooleamFilterOption[BooleamFilterOption["Yes"] = 1] = "Yes";
+            BooleamFilterOption[BooleamFilterOption["No"] = 2] = "No";
+        })(BooleamFilterOption = PeopleRollupEnums.BooleamFilterOption || (PeopleRollupEnums.BooleamFilterOption = {}));
+        let RefinerOrderBy;
+        (function (RefinerOrderBy) {
+            RefinerOrderBy[RefinerOrderBy["Count"] = 1] = "Count";
+            RefinerOrderBy[RefinerOrderBy["Alphabetic"] = 2] = "Alphabetic";
+        })(RefinerOrderBy = PeopleRollupEnums.RefinerOrderBy || (PeopleRollupEnums.RefinerOrderBy = {}));
+        let Positions;
+        (function (Positions) {
+            Positions[Positions["Top"] = 1] = "Top";
+            Positions[Positions["Left"] = 2] = "Left";
+            Positions[Positions["Right"] = 3] = "Right";
+        })(Positions = PeopleRollupEnums.Positions || (PeopleRollupEnums.Positions = {}));
+        let DateTimeMode;
+        (function (DateTimeMode) {
+            DateTimeMode[DateTimeMode["Normal"] = 1] = "Normal";
+            DateTimeMode[DateTimeMode["Social"] = 2] = "Social";
+        })(DateTimeMode = PeopleRollupEnums.DateTimeMode || (PeopleRollupEnums.DateTimeMode = {}));
+        let ManagedPropertyOption;
+        (function (ManagedPropertyOption) {
+            ManagedPropertyOption[ManagedPropertyOption["Refinable"] = 1] = "Refinable";
+            ManagedPropertyOption[ManagedPropertyOption["Retrievable"] = 2] = "Retrievable";
+            ManagedPropertyOption[ManagedPropertyOption["Sortable"] = 3] = "Sortable";
+            ManagedPropertyOption[ManagedPropertyOption["Queryable"] = 4] = "Queryable";
+        })(ManagedPropertyOption = PeopleRollupEnums.ManagedPropertyOption || (PeopleRollupEnums.ManagedPropertyOption = {}));
+        let DatePeriods;
+        (function (DatePeriods) {
+            DatePeriods[DatePeriods["NoLimit"] = 0] = "NoLimit";
+            DatePeriods[DatePeriods["OneWeekFromToday"] = 1] = "OneWeekFromToday";
+            DatePeriods[DatePeriods["TwoWeeksFromToday"] = 2] = "TwoWeeksFromToday";
+            DatePeriods[DatePeriods["OneMonthFromToday"] = 3] = "OneMonthFromToday";
+        })(DatePeriods = PeopleRollupEnums.DatePeriods || (PeopleRollupEnums.DatePeriods = {}));
+        let QueryType;
+        (function (QueryType) {
+            QueryType[QueryType["ProfileQuery"] = 0] = "ProfileQuery";
+            QueryType[QueryType["SharePointGroups"] = 1] = "SharePointGroups";
+            QueryType[QueryType["ActivityQuery"] = 2] = "ActivityQuery";
+            QueryType[QueryType["UserFieldsOnPage"] = 3] = "UserFieldsOnPage";
+            QueryType[QueryType["Birthday"] = 4] = "Birthday";
+        })(QueryType = PeopleRollupEnums.QueryType || (PeopleRollupEnums.QueryType = {}));
+        let BirthdayPeriod;
+        (function (BirthdayPeriod) {
+            BirthdayPeriod[BirthdayPeriod["NoLimit"] = 0] = "NoLimit";
+            BirthdayPeriod[BirthdayPeriod["Today"] = 1] = "Today";
+            BirthdayPeriod[BirthdayPeriod["OneMonthFromToday"] = 2] = "OneMonthFromToday";
+        })(BirthdayPeriod = PeopleRollupEnums.BirthdayPeriod || (PeopleRollupEnums.BirthdayPeriod = {}));
+    })(PeopleRollupEnums = Enums.PeopleRollupEnums || (Enums.PeopleRollupEnums = {}));
+    let ChromeMode;
+    (function (ChromeMode) {
+        ChromeMode[ChromeMode["Full"] = 0] = "Full";
+        ChromeMode[ChromeMode["Compact"] = 1] = "Compact";
+    })(ChromeMode = Enums.ChromeMode || (Enums.ChromeMode = {}));
+    let NavigationBarPosition;
+    (function (NavigationBarPosition) {
+        NavigationBarPosition[NavigationBarPosition["Top"] = 0] = "Top";
+        NavigationBarPosition[NavigationBarPosition["Left"] = 1] = "Left";
+    })(NavigationBarPosition = Enums.NavigationBarPosition || (Enums.NavigationBarPosition = {}));
+    let Alignment;
+    (function (Alignment) {
+        Alignment[Alignment["Left"] = 1] = "Left";
+        Alignment[Alignment["Center"] = 2] = "Center";
+        Alignment[Alignment["Right"] = 3] = "Right";
+    })(Alignment = Enums.Alignment || (Enums.Alignment = {}));
+})(Enums = exports.Enums || (exports.Enums = {}));

package/internal-do-not-import-from-here/models/FollowedsitesUpdatedAtUserPropertyBag.d.ts

@@ -0,0 +1,5 @@
+import { UserPropertyBagModel } from "@omnia/fx-models";
+export declare class FollowedsitesUpdatedAtUserPropertyBag extends UserPropertyBagModel {
+    followedsitesUpdatedAt: number;
+    constructor(updatedAt?: number);
+}

package/internal-do-not-import-from-here/models/FollowedsitesUpdatedAtUserPropertyBag.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FollowedsitesUpdatedAtUserPropertyBag = void 0;
+const fx_models_1 = require("@omnia/fx-models");
+class FollowedsitesUpdatedAtUserPropertyBag extends fx_models_1.UserPropertyBagModel {
+    constructor(updatedAt) {
+        super(fx_models_1.OmniaService.Id, "followedsitesUpdatedAt");
+        this.followedsitesUpdatedAt = updatedAt;
+    }
+}
+exports.FollowedsitesUpdatedAtUserPropertyBag = FollowedsitesUpdatedAtUserPropertyBag;

package/internal-do-not-import-from-here/models/FooterSettings.d.ts

@@ -0,0 +1,16 @@
+export interface FooterSetting {
+    position: FooterPositions;
+    sytemCss: string;
+    css: string;
+    js: string;
+    content: string;
+    editMode: EditModes;
+}
+export declare enum EditModes {
+    Script = 0,
+    RTF = 1
+}
+export declare enum FooterPositions {
+    Fixed = 0,
+    Absolute = 1
+}

package/internal-do-not-import-from-here/models/FooterSettings.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FooterPositions = exports.EditModes = void 0;
+var EditModes;
+(function (EditModes) {
+    EditModes[EditModes["Script"] = 0] = "Script";
+    EditModes[EditModes["RTF"] = 1] = "RTF";
+})(EditModes = exports.EditModes || (exports.EditModes = {}));
+var FooterPositions;
+(function (FooterPositions) {
+    FooterPositions[FooterPositions["Fixed"] = 0] = "Fixed";
+    FooterPositions[FooterPositions["Absolute"] = 1] = "Absolute";
+})(FooterPositions = exports.FooterPositions || (exports.FooterPositions = {}));

package/internal-do-not-import-from-here/models/GovernanceDashboards.d.ts

@@ -0,0 +1,56 @@
+import { Guid, IIcon, MultilingualString, SpacingSettings } from "@omnia/fx-models";
+export interface DashboardScopeMessage {
+    id: Guid;
+    title: string;
+}
+export interface DashboardScope extends DashboardScopeMessage {
+    scopeQuery?: {
+        [filterId: string]: FilterValue;
+    };
+    filters: DashboardFilter[];
+    metrics: DashboardMetricBlock[];
+}
+export interface DashboardViewConfig {
+    indicatorCols: number;
+    filterCols: number;
+}
+export interface DashboardMetric {
+    scopeId: Guid;
+    id: Guid;
+    title: string;
+    indicatorElementToRender: string;
+    detailElementToRender: string;
+    settingElementToRender?: string;
+}
+export interface DashboardMetricSettings {
+    multilingualTitle: MultilingualString;
+    id: string;
+    description?: MultilingualString;
+    icon?: IIcon;
+    color?: string;
+}
+export interface DashboardMetricBlock<T extends DashboardMetricSettings = DashboardMetricSettings> extends DashboardMetric {
+    config: T;
+}
+export interface GovernanceDashboardsBlockSettings {
+    title: MultilingualString;
+    scope: DashboardScope;
+    filtersPerRow: number;
+    indicatorsPerRow: number;
+    spacing?: SpacingSettings;
+    height: number;
+}
+export interface DashboardFilter extends FilterDefinitionIdentity {
+    scopeId: Guid;
+    filterId: Guid;
+    title: string;
+    elementToRender: string;
+    scopeQuery?: boolean;
+    supportedFilterIds?: Guid[];
+}
+export interface FilterDefinitionIdentity {
+    readonly filterId: Guid;
+}
+export declare abstract class FilterValue implements FilterDefinitionIdentity {
+    abstract readonly filterId: Guid;
+}

package/internal-do-not-import-from-here/models/GovernanceDashboards.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilterValue = void 0;
+class FilterValue {
+}
+exports.FilterValue = FilterValue;
+// -------------------------------------------------------------------------
+// DUC: still not find use class FilterValue is easier than use DashboardFilterValue<T>
+// With FilterValue every filter need defnied new class to use.
+// With DashboardFilterValue<T> we just use it.
+// Other issue with FilterValue is in GovernanceDashboard.tsx and GovernanceDashboardSettings.tsx there is no way we can check value of filter is exist or not
+// We will need init FilterValue Object as {} to have javascript referent so it will update data without doing anthing but then we can not know when filter value have value
+// Because the implement of every filter will different
+// -------------------------------------------------------------------------
+//export interface DashboardFilterValue<T extends any = any>
+//{
+//    filterId: Guid;
+//    value: T;
+//}

package/internal-do-not-import-from-here/models/HeaderSetting.d.ts

@@ -0,0 +1,25 @@
+import { Search } from "../../search/models";
+export interface HeaderSearchSetting {
+    showSearchBoxOnHeader: boolean;
+    searchStringToQueryString: boolean;
+    searchSettings: Search.SearchSettings;
+}
+export interface HeaderStyleSetting {
+    backgroundColor: string;
+    iconColor: string;
+}
+export interface HeaderSettingsSection {
+    /**
+     * The title of the navigation node
+     */
+    title: string;
+    /**
+     * The element that will be rendered when selected
+     */
+    elementToRender: string;
+    /**
+     * This influence the order of the navigation nodes, be nice, use ordering with gap -100, 0, 100, 200
+       So other extensions etc can inject between
+     */
+    weight: number;
+}

package/internal-do-not-import-from-here/models/HeaderSetting.js

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

package/internal-do-not-import-from-here/models/IAdminComponent.d.ts

@@ -0,0 +1,5 @@
+import { AdminNavigationBuiltInCategory, JourneyInstance } from "@omnia/fx/models";
+export interface IAdminComponent {
+    category: AdminNavigationBuiltInCategory;
+    getJourney: () => JourneyInstance;
+}

package/internal-do-not-import-from-here/models/IAdminComponent.js

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

package/internal-do-not-import-from-here/models/ISearchTemplate.d.ts

@@ -0,0 +1,24 @@
+import { SharePointSearchResultItem } from "./Search";
+import { GuidValue } from "@omnia/fx/models";
+export interface SearchItemClickedOptions {
+    /**
+     * The custom action always runs before close search dialog or clear the search result
+     * */
+    customAction: () => Promise<void>;
+    /**
+     * Clear the search result and search text box
+     * */
+    clearSearchResult: boolean;
+    /**
+     * Close the search dialog
+     * */
+    closeDialog: boolean;
+}
+export interface ISearchTemplate {
+    dataRow: SharePointSearchResultItem;
+    /**
+     * Capture viewed search result item if collect statistics is enabled and handle to close search dialog
+     * */
+    onItemClicked?: (searchCategoryId?: GuidValue, itemUrl?: string, itemClickedOptions?: SearchItemClickedOptions) => void;
+    searchCategoryId?: GuidValue;
+}

package/internal-do-not-import-from-here/models/ISearchTemplate.js

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

package/internal-do-not-import-from-here/models/LogoSettings.d.ts

@@ -0,0 +1,9 @@
+import { MediaPickerImage, MultilingualString } from "@omnia/fx-models";
+export interface LogoSettings {
+    text: MultilingualString;
+    image?: MediaPickerImage;
+    logoText?: MultilingualString;
+}
+export interface ProfileOverrideHeaderLogoSettings extends LogoSettings {
+    inheritTenantHome: boolean;
+}

package/internal-do-not-import-from-here/models/LogoSettings.js

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