@omnia/fx-models 8.0.462-dev → 8.0.464-dev

package/shared-mobile/SharedMobileEnums.d.ts

@@ -0,0 +1,183 @@
+import { guid } from "@omnia/fx-models/internal-do-not-import-from-here/shared/models";
+export declare enum BoolFilter {
+    Both = 0,
+    True = 1,
+    False = 2
+}
+export declare namespace MediaPickerEnums {
+    enum ScalingFormatTypes {
+        KeepFormat = 0,
+        Jpeg = 1
+    }
+    enum ImageRatioTypes {
+        Landscape = 0,
+        Square = 1,
+        Portrait = 2,
+        Wide = 3
+    }
+    enum MediaPickerTransformationTypes {
+        Crop = 0,
+        Flip = 1,
+        Filter = 2
+    }
+    enum OmniaMediaTypes {
+        Image = 0,
+        Video = 1
+    }
+    enum LoadingStyle {
+        overlay = 0,
+        noOverlay = 1
+    }
+    enum MediaSearchStatus {
+        Initial = 0,
+        Searching = 1,
+        Finish = 2,
+        Error = 3
+    }
+}
+export declare enum LanguageTags {
+    ArSa = "ar-sa",
+    BgBg = "bg-bg",
+    CaEs = "ca-es",
+    ZhTw = "zh-tw",
+    CsCz = "cs-cz",
+    DaDk = "da-dk",
+    DeDe = "de-de",
+    ElGr = "el-gr",
+    EnUs = "en-us",
+    FiFi = "fi-fi",
+    FrFr = "fr-fr",
+    HeIl = "he-il",
+    HuHu = "hu-hu",
+    IsIs = "is-is",
+    ItIt = "it-it",
+    JaJp = "ja-jp",
+    KoKr = "ko-kr",
+    NlNl = "nl-nl",
+    NbNo = "nb-no",
+    PlPl = "pl-pl",
+    PtBr = "pt-br",
+    RoRo = "ro-ro",
+    RuRu = "ru-ru",
+    HrHr = "hr-hr",
+    SkSk = "sk-sk",
+    SqAl = "sq-al",
+    SvSe = "sv-se",
+    ThTh = "th-th",
+    TrTr = "tr-tr",
+    UrPk = "ur-pk",
+    IdId = "id-id",
+    UkUa = "uk-ua",
+    BeBy = "be-by",
+    SlSi = "sl-si",
+    EtEe = "et-ee",
+    LvLv = "lv-lv",
+    LtLt = "lt-lt",
+    FaIr = "fa-ir",
+    ViVn = "vi-vn",
+    HyAm = "hy-am",
+    EuEs = "eu-es",
+    MkMk = "mk-mk",
+    AfZa = "af-za",
+    KaGe = "ka-ge",
+    FoFo = "fo-fo",
+    HiIn = "hi-in",
+    MsMy = "ms-my",
+    KkKz = "kk-kz",
+    KyKg = "ky-kg",
+    SwKe = "sw-ke",
+    TtRu = "tt-ru",
+    PaIn = "pa-in",
+    GuIn = "gu-in",
+    TaIn = "ta-in",
+    TeIn = "te-in",
+    KnIn = "kn-in",
+    MrIn = "mr-in",
+    SaIn = "sa-in",
+    MnMn = "mn-mn",
+    GlEs = "gl-es",
+    DvMv = "dv-mv",
+    ArIq = "ar-iq",
+    ZhCn = "zh-cn",
+    DeCh = "de-ch",
+    EnGb = "en-gb",
+    EsMx = "es-mx",
+    FrBe = "fr-be",
+    ItCh = "it-ch",
+    NlBe = "nl-be",
+    NnNo = "nn-no",
+    PtPt = "pt-pt",
+    SvFi = "sv-fi",
+    MsBn = "ms-bn",
+    ArEg = "ar-eg",
+    ZhHk = "zh-hk",
+    DeAt = "de-at",
+    EnAu = "en-au",
+    EnEs = "en-es",
+    FrCa = "fr-ca",
+    ArLy = "ar-ly",
+    ZhSg = "zh-sg",
+    DeLu = "de-lu",
+    EnCa = "en-ca",
+    EsGt = "es-gt",
+    FrCh = "fr-ch",
+    ArDz = "ar-dz",
+    ZhMo = "zh-mo",
+    DeLi = "de-li",
+    EnNz = "en-nz",
+    EsCr = "es-cr",
+    FrLu = "fr-lu",
+    ArMa = "ar-ma",
+    EnIe = "en-ie",
+    EsPa = "es-pa",
+    FrMc = "fr-mc",
+    ArTn = "ar-tn",
+    EnZa = "en-za",
+    EsDo = "es-do",
+    ArOm = "ar-om",
+    EnJm = "en-jm",
+    EsVe = "es-ve",
+    ArYe = "ar-ye",
+    EsCo = "es-co",
+    ArSy = "ar-sy",
+    EnBz = "en-bz",
+    EsPe = "es-pe",
+    ArJo = "ar-jo",
+    EnTt = "en-tt",
+    EsAr = "es-ar",
+    ArLb = "ar-lb",
+    EnZw = "en-zw",
+    EsEc = "es-ec",
+    EsEs = "es-es",
+    ArKw = "ar-kw",
+    EnPh = "en-ph",
+    EsCl = "es-cl",
+    ArAe = "ar-ae",
+    EsUy = "es-uy",
+    ArBh = "ar-bh",
+    EsPy = "es-py",
+    ArQa = "ar-qa",
+    EsBo = "es-bo",
+    EsSv = "es-sv",
+    EsHn = "es-hn",
+    EsPr = "es-pr",
+    ZuZa = "zu-za",
+    XhZa = "xh-za",
+    FyNl = "fy-nl",
+    TnZa = "tn-za",
+    SeSe = "se-se",
+    SeFi = "se-fi",
+    CyGb = "cy-gb",
+    HrBa = "hr-ba",
+    MiNz = "mi-nz",
+    GaIe = "ga-ie",
+    RmCh = "rm-ch",
+    LbLu = "lb-lu",
+    NsZa = "ns-za",
+    SeNo = "se-no",
+    MtMt = "mt-mt"
+}
+export declare const SecurityIdentities: {
+    OverridenRulesBindingIdentityId: guid;
+    AnonymousIdentity: guid;
+};

package/shared-mobile/SharedMobileEnums.js

@@ -0,0 +1,195 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SecurityIdentities = exports.LanguageTags = exports.MediaPickerEnums = exports.BoolFilter = void 0;
+const models_1 = require("@omnia/fx-models/internal-do-not-import-from-here/shared/models");
+var BoolFilter;
+(function (BoolFilter) {
+    BoolFilter[BoolFilter["Both"] = 0] = "Both";
+    BoolFilter[BoolFilter["True"] = 1] = "True";
+    BoolFilter[BoolFilter["False"] = 2] = "False";
+})(BoolFilter || (exports.BoolFilter = BoolFilter = {}));
+var MediaPickerEnums;
+(function (MediaPickerEnums) {
+    let ScalingFormatTypes;
+    (function (ScalingFormatTypes) {
+        ScalingFormatTypes[ScalingFormatTypes["KeepFormat"] = 0] = "KeepFormat";
+        ScalingFormatTypes[ScalingFormatTypes["Jpeg"] = 1] = "Jpeg";
+    })(ScalingFormatTypes = MediaPickerEnums.ScalingFormatTypes || (MediaPickerEnums.ScalingFormatTypes = {}));
+    let ImageRatioTypes;
+    (function (ImageRatioTypes) {
+        ImageRatioTypes[ImageRatioTypes["Landscape"] = 0] = "Landscape";
+        ImageRatioTypes[ImageRatioTypes["Square"] = 1] = "Square";
+        ImageRatioTypes[ImageRatioTypes["Portrait"] = 2] = "Portrait";
+        ImageRatioTypes[ImageRatioTypes["Wide"] = 3] = "Wide";
+    })(ImageRatioTypes = MediaPickerEnums.ImageRatioTypes || (MediaPickerEnums.ImageRatioTypes = {}));
+    let MediaPickerTransformationTypes;
+    (function (MediaPickerTransformationTypes) {
+        MediaPickerTransformationTypes[MediaPickerTransformationTypes["Crop"] = 0] = "Crop";
+        MediaPickerTransformationTypes[MediaPickerTransformationTypes["Flip"] = 1] = "Flip";
+        MediaPickerTransformationTypes[MediaPickerTransformationTypes["Filter"] = 2] = "Filter";
+    })(MediaPickerTransformationTypes = MediaPickerEnums.MediaPickerTransformationTypes || (MediaPickerEnums.MediaPickerTransformationTypes = {}));
+    let OmniaMediaTypes;
+    (function (OmniaMediaTypes) {
+        OmniaMediaTypes[OmniaMediaTypes["Image"] = 0] = "Image";
+        OmniaMediaTypes[OmniaMediaTypes["Video"] = 1] = "Video";
+    })(OmniaMediaTypes = MediaPickerEnums.OmniaMediaTypes || (MediaPickerEnums.OmniaMediaTypes = {}));
+    let LoadingStyle;
+    (function (LoadingStyle) {
+        LoadingStyle[LoadingStyle["overlay"] = 0] = "overlay";
+        LoadingStyle[LoadingStyle["noOverlay"] = 1] = "noOverlay";
+    })(LoadingStyle = MediaPickerEnums.LoadingStyle || (MediaPickerEnums.LoadingStyle = {}));
+    let MediaSearchStatus;
+    (function (MediaSearchStatus) {
+        MediaSearchStatus[MediaSearchStatus["Initial"] = 0] = "Initial";
+        MediaSearchStatus[MediaSearchStatus["Searching"] = 1] = "Searching";
+        MediaSearchStatus[MediaSearchStatus["Finish"] = 2] = "Finish";
+        MediaSearchStatus[MediaSearchStatus["Error"] = 3] = "Error";
+    })(MediaSearchStatus = MediaPickerEnums.MediaSearchStatus || (MediaPickerEnums.MediaSearchStatus = {}));
+})(MediaPickerEnums || (exports.MediaPickerEnums = MediaPickerEnums = {}));
+var LanguageTags;
+(function (LanguageTags) {
+    LanguageTags["ArSa"] = "ar-sa";
+    LanguageTags["BgBg"] = "bg-bg";
+    LanguageTags["CaEs"] = "ca-es";
+    LanguageTags["ZhTw"] = "zh-tw";
+    LanguageTags["CsCz"] = "cs-cz";
+    LanguageTags["DaDk"] = "da-dk";
+    LanguageTags["DeDe"] = "de-de";
+    LanguageTags["ElGr"] = "el-gr";
+    LanguageTags["EnUs"] = "en-us";
+    LanguageTags["FiFi"] = "fi-fi";
+    LanguageTags["FrFr"] = "fr-fr";
+    LanguageTags["HeIl"] = "he-il";
+    LanguageTags["HuHu"] = "hu-hu";
+    LanguageTags["IsIs"] = "is-is";
+    LanguageTags["ItIt"] = "it-it";
+    LanguageTags["JaJp"] = "ja-jp";
+    LanguageTags["KoKr"] = "ko-kr";
+    LanguageTags["NlNl"] = "nl-nl";
+    LanguageTags["NbNo"] = "nb-no";
+    LanguageTags["PlPl"] = "pl-pl";
+    LanguageTags["PtBr"] = "pt-br";
+    LanguageTags["RoRo"] = "ro-ro";
+    LanguageTags["RuRu"] = "ru-ru";
+    LanguageTags["HrHr"] = "hr-hr";
+    LanguageTags["SkSk"] = "sk-sk";
+    LanguageTags["SqAl"] = "sq-al";
+    LanguageTags["SvSe"] = "sv-se";
+    LanguageTags["ThTh"] = "th-th";
+    LanguageTags["TrTr"] = "tr-tr";
+    LanguageTags["UrPk"] = "ur-pk";
+    LanguageTags["IdId"] = "id-id";
+    LanguageTags["UkUa"] = "uk-ua";
+    LanguageTags["BeBy"] = "be-by";
+    LanguageTags["SlSi"] = "sl-si";
+    LanguageTags["EtEe"] = "et-ee";
+    LanguageTags["LvLv"] = "lv-lv";
+    LanguageTags["LtLt"] = "lt-lt";
+    LanguageTags["FaIr"] = "fa-ir";
+    LanguageTags["ViVn"] = "vi-vn";
+    LanguageTags["HyAm"] = "hy-am";
+    LanguageTags["EuEs"] = "eu-es";
+    LanguageTags["MkMk"] = "mk-mk";
+    LanguageTags["AfZa"] = "af-za";
+    LanguageTags["KaGe"] = "ka-ge";
+    LanguageTags["FoFo"] = "fo-fo";
+    LanguageTags["HiIn"] = "hi-in";
+    LanguageTags["MsMy"] = "ms-my";
+    LanguageTags["KkKz"] = "kk-kz";
+    LanguageTags["KyKg"] = "ky-kg";
+    LanguageTags["SwKe"] = "sw-ke";
+    LanguageTags["TtRu"] = "tt-ru";
+    LanguageTags["PaIn"] = "pa-in";
+    LanguageTags["GuIn"] = "gu-in";
+    LanguageTags["TaIn"] = "ta-in";
+    LanguageTags["TeIn"] = "te-in";
+    LanguageTags["KnIn"] = "kn-in";
+    LanguageTags["MrIn"] = "mr-in";
+    LanguageTags["SaIn"] = "sa-in";
+    LanguageTags["MnMn"] = "mn-mn";
+    LanguageTags["GlEs"] = "gl-es";
+    LanguageTags["DvMv"] = "dv-mv";
+    LanguageTags["ArIq"] = "ar-iq";
+    LanguageTags["ZhCn"] = "zh-cn";
+    LanguageTags["DeCh"] = "de-ch";
+    LanguageTags["EnGb"] = "en-gb";
+    LanguageTags["EsMx"] = "es-mx";
+    LanguageTags["FrBe"] = "fr-be";
+    LanguageTags["ItCh"] = "it-ch";
+    LanguageTags["NlBe"] = "nl-be";
+    LanguageTags["NnNo"] = "nn-no";
+    LanguageTags["PtPt"] = "pt-pt";
+    LanguageTags["SvFi"] = "sv-fi";
+    LanguageTags["MsBn"] = "ms-bn";
+    LanguageTags["ArEg"] = "ar-eg";
+    LanguageTags["ZhHk"] = "zh-hk";
+    LanguageTags["DeAt"] = "de-at";
+    LanguageTags["EnAu"] = "en-au";
+    LanguageTags["EnEs"] = "en-es";
+    LanguageTags["FrCa"] = "fr-ca";
+    LanguageTags["ArLy"] = "ar-ly";
+    LanguageTags["ZhSg"] = "zh-sg";
+    LanguageTags["DeLu"] = "de-lu";
+    LanguageTags["EnCa"] = "en-ca";
+    LanguageTags["EsGt"] = "es-gt";
+    LanguageTags["FrCh"] = "fr-ch";
+    LanguageTags["ArDz"] = "ar-dz";
+    LanguageTags["ZhMo"] = "zh-mo";
+    LanguageTags["DeLi"] = "de-li";
+    LanguageTags["EnNz"] = "en-nz";
+    LanguageTags["EsCr"] = "es-cr";
+    LanguageTags["FrLu"] = "fr-lu";
+    LanguageTags["ArMa"] = "ar-ma";
+    LanguageTags["EnIe"] = "en-ie";
+    LanguageTags["EsPa"] = "es-pa";
+    LanguageTags["FrMc"] = "fr-mc";
+    LanguageTags["ArTn"] = "ar-tn";
+    LanguageTags["EnZa"] = "en-za";
+    LanguageTags["EsDo"] = "es-do";
+    LanguageTags["ArOm"] = "ar-om";
+    LanguageTags["EnJm"] = "en-jm";
+    LanguageTags["EsVe"] = "es-ve";
+    LanguageTags["ArYe"] = "ar-ye";
+    LanguageTags["EsCo"] = "es-co";
+    LanguageTags["ArSy"] = "ar-sy";
+    LanguageTags["EnBz"] = "en-bz";
+    LanguageTags["EsPe"] = "es-pe";
+    LanguageTags["ArJo"] = "ar-jo";
+    LanguageTags["EnTt"] = "en-tt";
+    LanguageTags["EsAr"] = "es-ar";
+    LanguageTags["ArLb"] = "ar-lb";
+    LanguageTags["EnZw"] = "en-zw";
+    LanguageTags["EsEc"] = "es-ec";
+    LanguageTags["EsEs"] = "es-es";
+    LanguageTags["ArKw"] = "ar-kw";
+    LanguageTags["EnPh"] = "en-ph";
+    LanguageTags["EsCl"] = "es-cl";
+    LanguageTags["ArAe"] = "ar-ae";
+    LanguageTags["EsUy"] = "es-uy";
+    LanguageTags["ArBh"] = "ar-bh";
+    LanguageTags["EsPy"] = "es-py";
+    LanguageTags["ArQa"] = "ar-qa";
+    LanguageTags["EsBo"] = "es-bo";
+    LanguageTags["EsSv"] = "es-sv";
+    LanguageTags["EsHn"] = "es-hn";
+    LanguageTags["EsPr"] = "es-pr";
+    LanguageTags["ZuZa"] = "zu-za";
+    LanguageTags["XhZa"] = "xh-za";
+    LanguageTags["FyNl"] = "fy-nl";
+    LanguageTags["TnZa"] = "tn-za";
+    LanguageTags["SeSe"] = "se-se";
+    LanguageTags["SeFi"] = "se-fi";
+    LanguageTags["CyGb"] = "cy-gb";
+    LanguageTags["HrBa"] = "hr-ba";
+    LanguageTags["MiNz"] = "mi-nz";
+    LanguageTags["GaIe"] = "ga-ie";
+    LanguageTags["RmCh"] = "rm-ch";
+    LanguageTags["LbLu"] = "lb-lu";
+    LanguageTags["NsZa"] = "ns-za";
+    LanguageTags["SeNo"] = "se-no";
+    LanguageTags["MtMt"] = "mt-mt";
+})(LanguageTags || (exports.LanguageTags = LanguageTags = {}));
+exports.SecurityIdentities = {
+    OverridenRulesBindingIdentityId: (0, models_1.guid)("ff000000-0000-ffff-0000-0000000000ff"),
+    AnonymousIdentity: (0, models_1.guid)("c2781205-d1c7-42e0-a270-4a43f94f6cf5")
+};

package/shared-mobile/identities/BuiltInIdentityProvider.d.ts

@@ -0,0 +1,7 @@
+import { guid } from "@omnia/fx-models/internal-do-not-import-from-here/shared/models";
+export declare class BuiltInIdentityProviderIds {
+    static get azureAd(): guid;
+    static get omnia(): guid;
+    static get ldap(): guid;
+    static get defaultAd(): guid;
+}

package/shared-mobile/identities/BuiltInIdentityProvider.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BuiltInIdentityProviderIds = void 0;
+const models_1 = require("@omnia/fx-models/internal-do-not-import-from-here/shared/models");
+class BuiltInIdentityProviderIds {
+    static get azureAd() {
+        return (0, models_1.guid)("bb9f80dd-9dfa-4147-b923-7e2f8e0e7a0c");
+    }
+    static get omnia() {
+        return (0, models_1.guid)("aa000000-0000-aaaa-0000-0000000000aa");
+    }
+    static get ldap() {
+        return (0, models_1.guid)("ab5c4983-1254-44d7-87e9-72021703dfc5");
+    }
+    static get defaultAd() {
+        if (globalThis.omnia?.enviroment?.backendRuntime === models_1.OmniaBackendRuntimes.SharePointServer) {
+            return this.ldap;
+        }
+        return this.azureAd;
+    }
+}
+exports.BuiltInIdentityProviderIds = BuiltInIdentityProviderIds;

package/shared-mobile/identities/GroupIdentity.d.ts

@@ -0,0 +1,54 @@
+import { guid, PropertyValueBinding } from "@omnia/fx-models/internal-do-not-import-from-here/shared/models";
+import { Identity, IResolvedIdentity } from "./Identity";
+import { IdentityTypes } from "./IdentityTypes";
+import { EmailPropertyDefinition, ImagePropertyDefinition, TextPropertyDefinition } from "../properties";
+import { ScopeTypes } from "./ScopeTypes";
+import { UserIdentity } from "./UserIdentity";
+export declare class GroupIdentity extends Identity {
+    type: IdentityTypes;
+}
+export declare class ResolvedGroupIdentity extends GroupIdentity implements IResolvedIdentity {
+    groupTypeId: guid;
+    providerId: guid;
+    propertyValues: PropertyValueBinding<any>[];
+    displayName: PropertyValueBinding<TextPropertyDefinition>;
+    email: PropertyValueBinding<EmailPropertyDefinition>;
+    image: PropertyValueBinding<TextPropertyDefinition>;
+    description: PropertyValueBinding<TextPropertyDefinition>;
+    scope: string;
+    scopeType: ScopeTypes;
+    isRemoved: boolean;
+    groupOwnerIds: Identity[];
+    static getDisplayName(group: ResolvedGroupIdentity, deletedGroupText: string): string;
+}
+export declare enum GroupSortColumn {
+    DisplayName = 1,
+    Description = 2,
+    ProviderId = 3,
+    GroupTypeId = 4
+}
+export interface GroupIdentityAddOrUpdateRequest {
+    id: guid;
+    providerId: guid;
+    displayName: PropertyValueBinding<TextPropertyDefinition>;
+    description: PropertyValueBinding<TextPropertyDefinition>;
+    email: PropertyValueBinding<EmailPropertyDefinition>;
+    icon: PropertyValueBinding<ImagePropertyDefinition>;
+    propertyValues: Array<PropertyValueBinding<any>>;
+    scope: string;
+    scopeType: ScopeTypes;
+    groupOwnerIds: Identity[];
+}
+export interface GroupMembershipUpdateRequest {
+    group: GroupIdentity;
+    users: UserIdentity[];
+    groups: GroupIdentity[];
+}
+export interface GroupIdentityAddOrUpdateWithMembershipRequest {
+    groupInformation: GroupIdentityAddOrUpdateRequest;
+    membership: GroupMembershipUpdateRequest;
+}
+export interface GroupIdentityAddOrUpdateWithMembershipResponse {
+    group: ResolvedGroupIdentity;
+    membership: Identity[];
+}

package/shared-mobile/identities/GroupIdentity.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GroupSortColumn = exports.ResolvedGroupIdentity = exports.GroupIdentity = void 0;
+const Identity_1 = require("./Identity");
+const IdentityTypes_1 = require("./IdentityTypes");
+class GroupIdentity extends Identity_1.Identity {
+    constructor() {
+        super(...arguments);
+        this.type = IdentityTypes_1.IdentityTypes.Group;
+    }
+}
+exports.GroupIdentity = GroupIdentity;
+class ResolvedGroupIdentity extends GroupIdentity {
+    static getDisplayName(group, deletedGroupText) {
+        return group.isRemoved ? deletedGroupText : group.displayName?.value.text;
+    }
+}
+exports.ResolvedGroupIdentity = ResolvedGroupIdentity;
+var GroupSortColumn;
+(function (GroupSortColumn) {
+    GroupSortColumn[GroupSortColumn["DisplayName"] = 1] = "DisplayName";
+    GroupSortColumn[GroupSortColumn["Description"] = 2] = "Description";
+    GroupSortColumn[GroupSortColumn["ProviderId"] = 3] = "ProviderId";
+    GroupSortColumn[GroupSortColumn["GroupTypeId"] = 4] = "GroupTypeId";
+})(GroupSortColumn || (exports.GroupSortColumn = GroupSortColumn = {}));

package/shared-mobile/identities/GroupMembers.d.ts

@@ -0,0 +1,6 @@
+import { GroupIdentity } from "./GroupIdentity";
+import { UserIdentity } from "./UserIdentity";
+export interface GroupMembers {
+    users: UserIdentity[];
+    groups: GroupIdentity[];
+}

package/shared-mobile/identities/GroupMembers.js

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

package/shared-mobile/identities/Identity.d.ts

@@ -0,0 +1,37 @@
+import { guid, IEquals, PropertyValueBinding } from "@omnia/fx-models/internal-do-not-import-from-here/shared/models";
+import { IdentityTypes } from "./IdentityTypes";
+interface IIdentityEqual extends IEquals<{
+    identity(value: Identity): boolean;
+}> {
+}
+export interface IResolvedIdentity extends Partial<IIdentityEqual> {
+    id: guid;
+    type: IdentityTypes;
+    providerId: guid;
+    isRemoved: boolean;
+    propertyValues: PropertyValueBinding<any>[];
+    toIdString?: () => string;
+}
+export declare abstract class Identity implements IIdentityEqual {
+    readonly id: guid;
+    abstract readonly type: IdentityTypes;
+    constructor(id: guid);
+    toIdString(): string;
+    get equals(): {
+        identity: (value: Identity) => boolean;
+    };
+    static parse(identity: Identity | IResolvedIdentity | string): Identity;
+    static isValid(identity: Identity): boolean;
+    static createFromString(idAndType: string): Identity;
+    private static getguid;
+    private static getIdAsString;
+}
+export declare enum ArchiveSortColumn {
+    DisplayName = 1,
+    Email = 2,
+    Username = 3,
+    IdentityType = 4,
+    ProviderId = 5,
+    TypeId = 6
+}
+export {};

package/shared-mobile/identities/Identity.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArchiveSortColumn = exports.Identity = void 0;
+const models_1 = require("@omnia/fx-models/internal-do-not-import-from-here/shared/models");
+const IdentityTypes_1 = require("./IdentityTypes");
+class Identity {
+    constructor(id) {
+        this.id = id;
+    }
+    toIdString() {
+        return Identity.getIdAsString(this.id, this.type);
+    }
+    get equals() {
+        return {
+            identity: (value) => {
+                return this.toIdString() === value.toIdString();
+            }
+        };
+    }
+    static parse(identity) {
+        if (!identity) {
+            return null;
+        }
+        if (typeof identity === "string") {
+            return this.createFromString(identity);
+        }
+        return this.createFromString(Identity.getIdAsString(identity.id, identity.type));
+    }
+    static isValid(identity) {
+        try {
+            Identity.createFromString(identity.toIdString());
+            return true;
+        }
+        catch (ex) {
+            return false;
+        }
+    }
+    static createFromString(idAndType) {
+        if (!idAndType) {
+            return null;
+        }
+        if (typeof idAndType === "string" && idAndType.toLowerCase().indexOf("2faa499e-907b-4fd2-b78b-420090ec813e") > -1) {
+            return this["createIdentity"](IdentityTypes_1.IdentityTypes.User, (0, models_1.guid)("2faa499e-907b-4fd2-b78b-420090ec813e")); // from Internal Identiy, to prevent circular reference
+        }
+        if (typeof idAndType === "object") {
+            if (!idAndType.toString()) {
+                throw new Error(`Can't create identity from string ${JSON.stringify(idAndType)} type is not valid`);
+            }
+            return this.createFromString(idAndType.toString());
+        }
+        let id = null;
+        let type = null;
+        const startIndex = idAndType.lastIndexOf("[");
+        const endIndex = idAndType.lastIndexOf("]");
+        if (startIndex > -1 && endIndex > -1) {
+            type = parseInt(idAndType.substring(startIndex + 1, endIndex));
+            id = this.getguid(idAndType);
+        }
+        if (id === null) {
+            throw new Error(`Can't create identity from string ${idAndType} type is not valid`);
+        }
+        return this["createIdentity"](type, id); // from Internal Identity, to prevent circular reference
+    }
+    static getguid(value) {
+        if (value) {
+            const matchs = value.match(/([A-Z0-9]{8}-[A-Z0-9]{4}-[A-Z0-9]{4}-[A-Z0-9]{4}-[A-Z0-9]{12})/i);
+            if (matchs)
+                return (0, models_1.maybeGuid)(matchs[0]);
+        }
+        return null;
+    }
+    static getIdAsString(id, type) {
+        return `${id.toLowerCase()}[${type}]`;
+    }
+}
+exports.Identity = Identity;
+var ArchiveSortColumn;
+(function (ArchiveSortColumn) {
+    ArchiveSortColumn[ArchiveSortColumn["DisplayName"] = 1] = "DisplayName";
+    ArchiveSortColumn[ArchiveSortColumn["Email"] = 2] = "Email";
+    ArchiveSortColumn[ArchiveSortColumn["Username"] = 3] = "Username";
+    ArchiveSortColumn[ArchiveSortColumn["IdentityType"] = 4] = "IdentityType";
+    ArchiveSortColumn[ArchiveSortColumn["ProviderId"] = 5] = "ProviderId";
+    ArchiveSortColumn[ArchiveSortColumn["TypeId"] = 6] = "TypeId";
+})(ArchiveSortColumn || (exports.ArchiveSortColumn = ArchiveSortColumn = {}));
+// only add extension methods when running in browser, not in node.js
+if (globalThis.omnia) {
+    Object.defineProperty(Object.prototype, "toIdString", {
+        value: function () {
+            return `${this.id.toLowerCase()}[${this.type}]`;
+        },
+        writable: false,
+        configurable: false,
+        enumerable: false
+    });
+    Object.defineProperty(String.prototype, "toIdString", {
+        value: function () {
+            return this.toString();
+        },
+        writable: false,
+        configurable: false,
+        enumerable: false
+    });
+    Object.defineProperty(String.prototype["equals"], "identity", {
+        value: function (value) {
+            return this["_this_value"].toIdString() === value.toIdString();
+        },
+        writable: false,
+        configurable: false,
+        enumerable: false
+    });
+}

package/shared-mobile/identities/IdentityQuery.d.ts

@@ -0,0 +1,26 @@
+import { IdentityTypes } from "./IdentityTypes";
+import { ItemQuery } from "../ItemQuery";
+import { guid } from "@omnia/fx-models/internal-do-not-import-from-here/shared/models";
+import { BoolFilter } from "../SharedMobileEnums";
+import { ScopeTypes } from "./ScopeTypes";
+export declare class IdentityQuery extends ItemQuery {
+    readonly types: IdentityTypes[];
+    searchText?: string;
+    /**
+     * This is user type id or group type id value.
+     */
+    typeIds?: guid[];
+    providerIds?: guid[];
+    excludeTypeIds?: guid[];
+    emailEnabled?: BoolFilter;
+    permissionEnabled?: BoolFilter;
+    scope?: string;
+    tenantIdentityOnly?: boolean;
+    businessProfileId?: guid;
+    scopeType?: ScopeTypes;
+    constructor(types: IdentityTypes[], searchText?: string, 
+    /**
+     * This is user type id or group type id value.
+     */
+    typeIds?: guid[], providerIds?: guid[], excludeTypeIds?: guid[], emailEnabled?: BoolFilter, permissionEnabled?: BoolFilter, scope?: string, tenantIdentityOnly?: boolean, businessProfileId?: guid, scopeType?: ScopeTypes);
+}