@sitecore/sc-contenthub-webclient-sdk 0.9.7

package/dist/mappers/member-condition-mapper.js

@@ -0,0 +1,119 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemberConditionMapper = void 0;
+const string_format_1 = __importDefault(require("string-format"));
+const member_condition_1 = require("../contracts/base/member-condition");
+const error_messages_1 = __importDefault(require("../error-messages"));
+const guard_1 = __importDefault(require("../guard"));
+const member_condition_resource_1 = require("../models/member-condition-resource");
+class MemberConditionMapper {
+    constructor(client) {
+        guard_1.default.notNullOrUndefined(client, "client");
+        this._client = client;
+    }
+    //#region To SDK
+    mapMemberConditionsAsync(conditionResources) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!conditionResources || conditionResources.length === 0)
+                return [];
+            const list = [];
+            for (const conditionResource of conditionResources) {
+                const condition = yield this.mapMemberConditionAsync(conditionResource);
+                if (condition != null) {
+                    list.push(condition);
+                }
+            }
+            return list;
+        });
+    }
+    mapMemberConditionAsync(conditionResource) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!conditionResource)
+                return null;
+            if (conditionResource instanceof member_condition_resource_1.NoAncestorMemberConditionResource) {
+                const definitionId = yield this._client.linkHelper.idFromEntityAsync(conditionResource.definition);
+                return new member_condition_1.NoAncestorMemberCondition(conditionResource.memberName, definitionId);
+            }
+            else if (conditionResource instanceof member_condition_resource_1.RelationMemberConditionResource) {
+                const valueId = yield this._client.linkHelper.idFromEntityAsync(conditionResource.value);
+                return new member_condition_1.RelationMemberCondition(conditionResource.memberName, valueId);
+            }
+            else if (conditionResource instanceof member_condition_resource_1.StringMemberConditionResource) {
+                return new member_condition_1.StringMemberCondition(conditionResource.memberName, conditionResource.value);
+            }
+            else if (conditionResource instanceof member_condition_resource_1.BooleanMemberConditionResource) {
+                return new member_condition_1.BooleanMemberCondition(conditionResource.memberName, conditionResource.value);
+            }
+            else {
+                throw string_format_1.default(error_messages_1.default.UnknownMemberCondition, conditionResource.constructor.name);
+            }
+        });
+    }
+    //#endregion
+    //#region To API resource
+    mapMemberConditionResourcesAsync(conditions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (conditions == null || conditions.length === 0)
+                return [];
+            const list = [];
+            for (const condition of conditions) {
+                const resource = yield this.mapMemberConditionResourceAsync(condition);
+                if (resource) {
+                    list.push(resource);
+                }
+            }
+            return list;
+        });
+    }
+    mapMemberConditionResourceAsync(condition) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (condition == null)
+                return null;
+            let resource;
+            if (condition instanceof member_condition_1.NoAncestorMemberCondition) {
+                const definitionName = yield this._client.entityDefinitions.getNameCachedAsync(condition.definitionId);
+                const definitionLink = yield this._client.linkHelper.definitionToLinkAsync(definitionName);
+                resource = new member_condition_resource_1.NoAncestorMemberConditionResource({
+                    memberName: condition.memberName,
+                    definition: definitionLink,
+                });
+            }
+            else if (condition instanceof member_condition_1.StringMemberCondition) {
+                resource = new member_condition_resource_1.StringMemberConditionResource({
+                    memberName: condition.memberName,
+                    value: condition.value,
+                });
+            }
+            else if (condition instanceof member_condition_1.BooleanMemberCondition) {
+                resource = new member_condition_resource_1.BooleanMemberConditionResource({
+                    memberName: condition.memberName,
+                    value: condition.value,
+                });
+            }
+            else if (condition instanceof member_condition_1.RelationMemberCondition) {
+                const definitionLink = yield this._client.linkHelper.entityToLinkAsync(condition.entityId);
+                resource = new member_condition_resource_1.RelationMemberConditionResource({
+                    memberName: condition.memberName,
+                    value: definitionLink,
+                });
+            }
+            else {
+                throw string_format_1.default(error_messages_1.default.UnknownMemberCondition, condition.constructor.name);
+            }
+            return resource;
+        });
+    }
+}
+exports.MemberConditionMapper = MemberConditionMapper;

package/dist/mappers/member-definition-mapper.d.ts

@@ -0,0 +1,19 @@
+import { NullableResultPromise } from "../base-types";
+import { IExtendedContentHubClient } from "../clients/extended-client";
+import { IMemberDefinition, PropertyDefinition, RelationDefinition } from "../contracts/base";
+import { MemberDefinitionResource } from "../models/member-definition-resource";
+import { PropertyDefinitionResource } from "../models/property-definition-resource";
+import { RelationDefinitionResource } from "../models/relation-definition-resource";
+export declare class MemberDefinitionMapper {
+    private readonly _client;
+    private readonly _memberConditionMapper;
+    constructor(client: IExtendedContentHubClient);
+    mapMemberDefinitionsAsync(memberDefinitionResources: Array<MemberDefinitionResource>): Promise<Array<IMemberDefinition>>;
+    mapMemberDefinitionAsync(resource: MemberDefinitionResource): NullableResultPromise<IMemberDefinition>;
+    mapPropertyDefinitionAsync(resource: PropertyDefinitionResource): Promise<PropertyDefinition>;
+    mapRelationDefinitionAsync(resource: RelationDefinitionResource): Promise<RelationDefinition>;
+    mapMemberDefinitionResourcesAsync(memberDefinitions: Array<IMemberDefinition>): Promise<Array<MemberDefinitionResource>>;
+    mapMemberDefinitionResourceAsync(memberDefinition: IMemberDefinition): NullableResultPromise<MemberDefinitionResource>;
+    mapPropertyDefinitionResourceAsync(definition: PropertyDefinition): NullableResultPromise<PropertyDefinitionResource>;
+    mapRelationDefinitionResourceAsync(definition: RelationDefinition): NullableResultPromise<RelationDefinitionResource>;
+}

package/dist/mappers/member-definition-mapper.js

@@ -0,0 +1,266 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemberDefinitionMapper = void 0;
+const string_format_1 = __importDefault(require("string-format"));
+const base_1 = require("../contracts/base");
+const data_type_1 = __importDefault(require("../contracts/base/data-type"));
+const error_messages_1 = __importDefault(require("../error-messages"));
+const guard_1 = __importDefault(require("../guard"));
+const property_definition_resource_1 = require("../models/property-definition-resource");
+const relation_definition_resource_1 = require("../models/relation-definition-resource");
+const member_condition_mapper_1 = require("./member-condition-mapper");
+const relation_cardinality_mapper_1 = require("./relation-cardinality-mapper");
+const relation_role_mapper_1 = require("./relation-role-mapper");
+class MemberDefinitionMapper {
+    constructor(client) {
+        guard_1.default.notNullOrUndefined(client, "client");
+        this._client = client;
+        this._memberConditionMapper = new member_condition_mapper_1.MemberConditionMapper(client);
+    }
+    //#region To SDK
+    mapMemberDefinitionsAsync(memberDefinitionResources) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!memberDefinitionResources || memberDefinitionResources.length === 0)
+                return [];
+            const list = [];
+            for (const memberDefinitionResource of memberDefinitionResources) {
+                const memberDefinition = yield this.mapMemberDefinitionAsync(memberDefinitionResource);
+                if (memberDefinition != null) {
+                    list.push(memberDefinition);
+                }
+            }
+            return list;
+        });
+    }
+    mapMemberDefinitionAsync(resource) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!resource)
+                return null;
+            let definition;
+            if (resource instanceof property_definition_resource_1.PropertyDefinitionResource) {
+                definition = yield this.mapPropertyDefinitionAsync(resource);
+            }
+            else if (resource instanceof relation_definition_resource_1.RelationDefinitionResource) {
+                definition = yield this.mapRelationDefinitionAsync(resource);
+            }
+            else {
+                throw "Unknown property definition type.";
+            }
+            definition.conditions = yield this._memberConditionMapper.mapMemberConditionsAsync(resource.conditions);
+            definition.isSecured = resource.isConditional != null ? resource.isSecured : false;
+            definition.isSystemOwned = resource.isSystemOwned;
+            definition.allowUpdates = resource.allowUpdates != null ? resource.allowUpdates : false;
+            definition.labels = JSON.parse(JSON.stringify(resource.labels));
+            definition.helpText = JSON.parse(JSON.stringify(resource.helpText));
+            return definition;
+        });
+    }
+    mapPropertyDefinitionAsync(resource) {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.notNullOrUndefined(resource);
+            const initObj = {
+                boost: (_a = resource.boost) !== null && _a !== void 0 ? _a : false,
+                includeInCompletion: (_b = resource.includeInCompletion) !== null && _b !== void 0 ? _b : false,
+                includeInContent: (_c = resource.includeInContent) !== null && _c !== void 0 ? _c : false,
+                indexed: (_d = resource.indexed) !== null && _d !== void 0 ? _d : false,
+                isMultiLanguage: (_e = resource.isMultiLanguage) !== null && _e !== void 0 ? _e : false,
+                isMandatory: (_f = resource.isMandatory) !== null && _f !== void 0 ? _f : false,
+                isMultiValue: (_g = resource.isMultiValue) !== null && _g !== void 0 ? _g : false,
+                isUnique: (_h = resource.isUnique) !== null && _h !== void 0 ? _h : false,
+            };
+            switch (resource.type) {
+                case data_type_1.default.Boolean:
+                    return new base_1.BooleanPropertyDefinition(resource.name, Object.assign({}, initObj));
+                case data_type_1.default.DateTime:
+                    return new base_1.DateTimePropertyDefinition(resource.name, Object.assign({}, initObj));
+                case data_type_1.default.DateTimeOffset:
+                    return new base_1.DateTimeOffsetPropertyDefinition(resource.name, Object.assign({}, initObj));
+                case data_type_1.default.Decimal:
+                    return new base_1.DecimalPropertyDefinition(resource.name, Object.assign({}, initObj));
+                case data_type_1.default.Integer:
+                    return new base_1.IntegerPropertyDefinition(resource.name, Object.assign({}, initObj));
+                case data_type_1.default.Json:
+                    const jsonPropResource = resource;
+                    return new base_1.JsonPropertyDefinition(resource.name, Object.assign(Object.assign({}, initObj), { contentType: jsonPropResource.contentType }));
+                case data_type_1.default.Long:
+                    return new base_1.LongPropertyDefinition(resource.name, Object.assign({}, initObj));
+                case data_type_1.default.String:
+                    const stringPropResource = resource;
+                    const dataSourceName = stringPropResource.dataSource &&
+                        (yield this._client.linkHelper.nameFromDataSourceAsync(stringPropResource.dataSource));
+                    return new base_1.StringPropertyDefinition(resource.name, Object.assign(Object.assign({}, initObj), { contentType: stringPropResource.contentType, validationExpression: stringPropResource.validationExpression, dataSourceName: dataSourceName }));
+                default:
+                    throw string_format_1.default(error_messages_1.default.UnsupportedMemberDefinition, resource.name, data_type_1.default[resource.type]);
+            }
+        });
+    }
+    mapRelationDefinitionAsync(resource) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.notNullOrUndefined(resource);
+            guard_1.default.notNullOrUndefined(resource.role, "role");
+            guard_1.default.notNullOrUndefined(resource.cardinality, "cardinality");
+            const associatedEntityDefinitionName = yield this._client.linkHelper.nameFromDefinitionAsync(resource.associatedEntityDefinition);
+            const relationDefinition = new base_1.RelationDefinition(resource.name, {
+                allowNavigation: resource.allowNavigation,
+                associatedEntityDefinitionName: associatedEntityDefinitionName != null ? associatedEntityDefinitionName : undefined,
+                pathHierarchyScore: resource.pathHierarchyScore,
+                childIsMandatory: resource.childIsMandatory != null ? resource.childIsMandatory : false,
+                parentIsMandatory: resource.parentIsMandatory != null ? resource.parentIsMandatory : false,
+                completionIsCopied: resource.completionIsCopied,
+                contentIsCopied: resource.contentIsCopied,
+                inheritsSecurity: resource.inheritsSecurity,
+                isNested: resource.isNested,
+                isPathHierarchyRelation: resource.isPathHierarchyRelation,
+                isPathRelation: resource.isPathRelation,
+                isRenditionRelation: resource.isRenditionRelation,
+                isTaxonomyHierarchyRelation: resource.isTaxonomyHierarchyRelation,
+                isTaxonomyRelation: resource.isTaxonomyRelation,
+                associatedLabels: JSON.parse(JSON.stringify(resource.associatedLabels)),
+                nestedPermissions: resource.nestedPermissions,
+                cardinality: relation_cardinality_mapper_1.RelationCardinalityMapper.mapToEnumValue(resource.cardinality),
+                role: relation_role_mapper_1.RelationRoleMapper.mapToEnumValue(resource.role),
+            });
+            if (resource.nestedProperties != null) {
+                relationDefinition.nestedProperties.push(...resource.nestedProperties);
+            }
+            return relationDefinition;
+        });
+    }
+    //#endregion
+    //#region To API resource
+    mapMemberDefinitionResourcesAsync(memberDefinitions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (memberDefinitions == null || memberDefinitions.length === 0)
+                return [];
+            const list = [];
+            for (const memberDefinition of memberDefinitions) {
+                const resource = yield this.mapMemberDefinitionResourceAsync(memberDefinition);
+                if (resource) {
+                    list.push(resource);
+                }
+            }
+            return list;
+        });
+    }
+    mapMemberDefinitionResourceAsync(memberDefinition) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!memberDefinition)
+                return null;
+            let resource;
+            if (memberDefinition instanceof base_1.PropertyDefinition) {
+                resource = yield this.mapPropertyDefinitionResourceAsync(memberDefinition);
+            }
+            else if (memberDefinition instanceof base_1.RelationDefinition) {
+                resource = yield this.mapRelationDefinitionResourceAsync(memberDefinition);
+            }
+            else {
+                throw string_format_1.default(error_messages_1.default.UnsupportedMemberDefinition, memberDefinition.name, data_type_1.default[memberDefinition.type]);
+            }
+            if (!resource)
+                return null;
+            resource.helpText = JSON.parse(JSON.stringify(memberDefinition.helpText));
+            resource.labels = JSON.parse(JSON.stringify(memberDefinition.labels));
+            resource.conditions = yield this._memberConditionMapper.mapMemberConditionResourcesAsync(memberDefinition.conditions);
+            resource.isConditional = memberDefinition.isConditional;
+            resource.isSecured = memberDefinition.isSecured;
+            resource.isSystemOwned = memberDefinition.isSystemOwned;
+            resource.name = memberDefinition.name;
+            resource.allowUpdates = memberDefinition.allowUpdates;
+            return resource;
+        });
+    }
+    mapPropertyDefinitionResourceAsync(definition) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!definition)
+                return null;
+            let resource;
+            const initObj = {
+                type: definition.type,
+                name: definition.name,
+                boost: definition.boost != null ? definition.boost : false,
+                includeInCompletion: definition.includeInCompletion,
+                includeInContent: definition.includeInContent,
+                indexed: definition.indexed,
+                isMandatory: definition.isMandatory,
+                isUnique: definition.isUnique,
+                isMultiLanguage: definition.isMultiLanguage,
+                isMultiValue: definition.isMultiValue,
+            };
+            switch (definition.type) {
+                case data_type_1.default.Boolean:
+                    resource = new property_definition_resource_1.BooleanPropertyDefinitionResource(Object.assign({}, initObj));
+                    break;
+                case data_type_1.default.DateTime:
+                    resource = new property_definition_resource_1.DateTimePropertyDefinitionResource(Object.assign({}, initObj));
+                    break;
+                case data_type_1.default.DateTimeOffset:
+                    resource = new property_definition_resource_1.DateTimeOffsetPropertyDefinitionResource(Object.assign({}, initObj));
+                    break;
+                case data_type_1.default.Decimal:
+                    resource = new property_definition_resource_1.DecimalPropertyDefinitionResource(Object.assign({}, initObj));
+                    break;
+                case data_type_1.default.Integer:
+                    resource = new property_definition_resource_1.IntegerPropertyDefinitionResource(Object.assign({}, initObj));
+                    break;
+                case data_type_1.default.Json:
+                    const jsonPropDefinition = definition;
+                    resource = new property_definition_resource_1.JsonPropertyDefinitionResource(Object.assign(Object.assign({}, initObj), { contentType: jsonPropDefinition.contentType }));
+                    break;
+                case data_type_1.default.Long:
+                    resource = new property_definition_resource_1.LongPropertyDefinitionResource(Object.assign({}, initObj));
+                    break;
+                case data_type_1.default.String:
+                    const stringPropDefinition = definition;
+                    const dataSourceLink = stringPropDefinition.dataSourceName &&
+                        (yield this._client.linkHelper.dataSourceToLinkAsync(stringPropDefinition.dataSourceName));
+                    resource = new property_definition_resource_1.StringPropertyDefinitionResource(Object.assign(Object.assign({}, initObj), { contentType: stringPropDefinition.contentType, validationExpression: stringPropDefinition.validationExpression, dataSource: dataSourceLink || null }));
+                    break;
+                default:
+                    throw string_format_1.default(error_messages_1.default.UnsupportedMemberDefinition, definition.name, data_type_1.default[definition.type]);
+            }
+            return resource;
+        });
+    }
+    mapRelationDefinitionResourceAsync(definition) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!definition)
+                return null;
+            const associatedEntityDefinitionLink = yield this._client.linkHelper.definitionToLinkAsync(definition.associatedEntityDefinitionName);
+            return new relation_definition_resource_1.RelationDefinitionResource({
+                associatedEntityDefinition: associatedEntityDefinitionLink,
+                allowNavigation: definition.allowNavigation,
+                associatedLabels: JSON.parse(JSON.stringify(definition.associatedLabels)),
+                pathHierarchyScore: definition.pathHierarchyScore,
+                childIsMandatory: definition.childIsMandatory,
+                completionIsCopied: definition.completionIsCopied,
+                contentIsCopied: definition.contentIsCopied,
+                inheritsSecurity: definition.inheritsSecurity,
+                isNested: definition.isNested,
+                isPathHierarchyRelation: definition.isPathHierarchyRelation,
+                isPathRelation: definition.isPathRelation,
+                isRenditionRelation: definition.isRenditionRelation,
+                isTaxonomyHierarchyRelation: definition.isTaxonomyHierarchyRelation,
+                isTaxonomyRelation: definition.isTaxonomyRelation,
+                nestedPermissions: definition.nestedPermissions,
+                nestedProperties: JSON.parse(JSON.stringify(definition.nestedProperties)),
+                parentIsMandatory: definition.parentIsMandatory,
+                cardinality: relation_cardinality_mapper_1.RelationCardinalityMapper.mapToType(definition.cardinality),
+                role: relation_role_mapper_1.RelationRoleMapper.mapToType(definition.role),
+            });
+        });
+    }
+}
+exports.MemberDefinitionMapper = MemberDefinitionMapper;

package/dist/mappers/member-group-mapper.d.ts

@@ -0,0 +1,14 @@
+import { NullableResultPromise } from "../base-types";
+import { IExtendedContentHubClient } from "../clients/extended-client";
+import { IMemberGroup } from "../contracts/base/member-group";
+import { MemberGroupResource } from "../models/member-group-resource";
+export declare class MemberGroupMapper {
+    private readonly _client;
+    private readonly _memberDefinitionMapper;
+    private readonly _memberConditionMapper;
+    constructor(client: IExtendedContentHubClient);
+    mapMemberGroupsAsync(groupResources: Array<MemberGroupResource>): Promise<Array<IMemberGroup>>;
+    mapMemberGroupAsync(groupResource: MemberGroupResource): NullableResultPromise<IMemberGroup>;
+    mapMemberGroupResourcesAsync(memberGroups: Array<IMemberGroup>): Promise<Array<MemberGroupResource>>;
+    mapMemberGroupResourceAsync(memberGroup: IMemberGroup): NullableResultPromise<MemberGroupResource>;
+}

package/dist/mappers/member-group-mapper.js

@@ -0,0 +1,95 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemberGroupMapper = void 0;
+const member_group_1 = require("../contracts/base/member-group");
+const guard_1 = __importDefault(require("../guard"));
+const member_group_resource_1 = require("../models/member-group-resource");
+const member_condition_mapper_1 = require("./member-condition-mapper");
+const member_definition_mapper_1 = require("./member-definition-mapper");
+class MemberGroupMapper {
+    constructor(client) {
+        guard_1.default.notNullOrUndefined(client, "client");
+        this._client = client;
+        this._memberDefinitionMapper = new member_definition_mapper_1.MemberDefinitionMapper(client);
+        this._memberConditionMapper = new member_condition_mapper_1.MemberConditionMapper(client);
+    }
+    //#region To SDK
+    mapMemberGroupsAsync(groupResources) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!groupResources || groupResources.length === 0)
+                return [];
+            const list = [];
+            for (const resource of groupResources) {
+                const group = yield this.mapMemberGroupAsync(resource);
+                if (group != null) {
+                    list.push(group);
+                }
+            }
+            return list;
+        });
+    }
+    mapMemberGroupAsync(groupResource) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!groupResource)
+                return null;
+            const memberGroup = new member_group_1.MemberGroup({
+                name: groupResource.name,
+                isSecured: groupResource.isSecured || false,
+                isSystemOwned: groupResource.isSystemOwned,
+                contentGroup: groupResource.contentGroup,
+                conditions: yield this._memberConditionMapper.mapMemberConditionsAsync(groupResource.conditions),
+                memberDefinitions: yield this._memberDefinitionMapper.mapMemberDefinitionsAsync(groupResource.memberDefinitions),
+                labels: JSON.parse(JSON.stringify(groupResource.labels)),
+            });
+            return memberGroup;
+        });
+    }
+    //#endregion
+    //#region To API resource
+    mapMemberGroupResourcesAsync(memberGroups) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!memberGroups || memberGroups.length === 0)
+                return [];
+            const list = [];
+            for (const memberGroup of memberGroups) {
+                const resource = yield this.mapMemberGroupResourceAsync(memberGroup);
+                if (resource) {
+                    list.push(resource);
+                }
+            }
+            return list;
+        });
+    }
+    mapMemberGroupResourceAsync(memberGroup) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (memberGroup == null)
+                return null;
+            const conditions = yield this._memberConditionMapper.mapMemberConditionResourcesAsync(memberGroup.conditions);
+            const memberDefinitions = yield this._memberDefinitionMapper.mapMemberDefinitionResourcesAsync(memberGroup.memberDefinitions);
+            const resource = new member_group_resource_1.MemberGroupResource({
+                name: memberGroup.name,
+                isSecured: memberGroup.isSecured != null ? memberGroup.isSecured : false,
+                isSystemOwned: memberGroup.isSystemOwned != null ? memberGroup.isSystemOwned : false,
+                contentGroup: memberGroup.contentGroup,
+                labels: JSON.parse(JSON.stringify(memberGroup.labels || {})),
+                conditions: conditions,
+                isConditional: memberGroup.isConditional,
+                memberDefinitions: memberDefinitions,
+            });
+            return resource;
+        });
+    }
+}
+exports.MemberGroupMapper = MemberGroupMapper;

package/dist/mappers/member-security-mapper.d.ts

@@ -0,0 +1,34 @@
+import { NullableResultPromise } from "../base-types";
+import { IExtendedContentHubClient } from "../clients/extended-client";
+import { IMemberPolicy } from "../contracts/policies/member-policy";
+import { MemberPolicyResource } from "../models/policies/member-policy-resource";
+export declare class MemberSecurityMapper {
+    /**
+     * Map policy resources to policies.
+     * @param client - An instance of an extended Content Hub client
+     * @param policyResources - A collection of resources to map
+     * @returns An array of policies.
+     */
+    static mapToMemberPoliciesAsync(client: IExtendedContentHubClient, policyResources: Array<MemberPolicyResource>): Promise<Array<IMemberPolicy>>;
+    /**
+     * Map a policy resource to a member policy instance.
+     * @param client - An instance of an extended Content Hub client
+     * @param policyResource - A policy resource
+     * @returns A member policy or null.
+     */
+    static mapToMemberPolicyAsync(client: IExtendedContentHubClient, policyResource: MemberPolicyResource): NullableResultPromise<IMemberPolicy>;
+    /**
+     * Map member policy instances to policy resources.
+     * @param client - An instance of an extended Content Hub client
+     * @param memberPolicies - A collection of member policies
+     * @returns An array of policy resources.
+     */
+    static mapToMemberPolicyResourcesAsync(client: IExtendedContentHubClient, memberPolicies: Array<IMemberPolicy>): Promise<Array<MemberPolicyResource>>;
+    /**
+     * Map a member policy to a policy resource.
+     * @param client - An instance of an extended Content Hub client
+     * @param memberPolicy - A member policy instance
+     * @returns A policy resource or null.
+     */
+    static mapToMemberPolicyResourceAsync(client: IExtendedContentHubClient, memberPolicy: IMemberPolicy): NullableResultPromise<MemberPolicyResource>;
+}

package/dist/mappers/member-security-mapper.js

@@ -0,0 +1,101 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemberSecurityMapper = void 0;
+const member_policy_1 = require("../contracts/policies/member-policy");
+const member_policy_resource_1 = require("../models/policies/member-policy-resource");
+class MemberSecurityMapper {
+    /**
+     * Map policy resources to policies.
+     * @param client - An instance of an extended Content Hub client
+     * @param policyResources - A collection of resources to map
+     * @returns An array of policies.
+     */
+    static mapToMemberPoliciesAsync(client, policyResources) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (policyResources == null) {
+                return [];
+            }
+            const list = [];
+            for (const memberPolicyResource of policyResources) {
+                const memberPolicy = yield this.mapToMemberPolicyAsync(client, memberPolicyResource);
+                if (memberPolicy != null) {
+                    list.push(memberPolicy);
+                }
+            }
+            return list;
+        });
+    }
+    /**
+     * Map a policy resource to a member policy instance.
+     * @param client - An instance of an extended Content Hub client
+     * @param policyResource - A policy resource
+     * @returns A member policy or null.
+     */
+    static mapToMemberPolicyAsync(client, policyResource) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (policyResource == null) {
+                return null;
+            }
+            const definitionName = yield client.linkHelper.nameFromDefinitionAsync(policyResource.definition);
+            const memberPolicy = new member_policy_1.MemberPolicy({
+                canRead: policyResource.canRead,
+                canWrite: policyResource.canWrite,
+                definitionName: definitionName,
+                target: policyResource.target,
+            });
+            return memberPolicy;
+        });
+    }
+    /**
+     * Map member policy instances to policy resources.
+     * @param client - An instance of an extended Content Hub client
+     * @param memberPolicies - A collection of member policies
+     * @returns An array of policy resources.
+     */
+    static mapToMemberPolicyResourcesAsync(client, memberPolicies) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (memberPolicies == null) {
+                return [];
+            }
+            const list = [];
+            for (const memberPolicy of memberPolicies) {
+                const policyResource = yield this.mapToMemberPolicyResourceAsync(client, memberPolicy);
+                if (policyResource != null) {
+                    list.push(policyResource);
+                }
+            }
+            return list;
+        });
+    }
+    /**
+     * Map a member policy to a policy resource.
+     * @param client - An instance of an extended Content Hub client
+     * @param memberPolicy - A member policy instance
+     * @returns A policy resource or null.
+     */
+    static mapToMemberPolicyResourceAsync(client, memberPolicy) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (memberPolicy == null) {
+                return null;
+            }
+            const definitionLink = yield client.linkHelper.definitionToLinkAsync(memberPolicy.definitionName);
+            const memberPolicyResource = new member_policy_resource_1.MemberPolicyResource({
+                canRead: memberPolicy.canRead,
+                canWrite: memberPolicy.canWrite,
+                definition: definitionLink,
+                target: memberPolicy.target,
+            });
+            return memberPolicyResource;
+        });
+    }
+}
+exports.MemberSecurityMapper = MemberSecurityMapper;

package/dist/mappers/notification-mapper.d.ts

@@ -0,0 +1,5 @@
+import { MapStringTo } from "../base-types";
+import { RealtimeRequest } from "../models/notifications/realtime-request";
+export declare class NotificationMapper {
+    static mapParameters(request: RealtimeRequest): MapStringTo<unknown>;
+}