@sitecore/sc-contenthub-webclient-sdk 0.9.7

package/dist/mappers/relation-mapper.js

@@ -0,0 +1,202 @@
+"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.RelationMapper = void 0;
+const string_format_1 = __importDefault(require("string-format"));
+const relation_1 = require("../contracts/base/relation");
+const relation_cardinality_1 = require("../contracts/base/relation-cardinality");
+const relation_role_1 = require("../contracts/base/relation-role");
+const child_to_many_parents_relation_1 = require("../contracts/base/relations/child-to-many-parents-relation");
+const child_to_one_parent_relation_1 = require("../contracts/base/relations/child-to-one-parent-relation");
+const parent_to_many_children_relation_1 = require("../contracts/base/relations/parent-to-many-children-relation");
+const parent_to_one_child_relation_1 = require("../contracts/base/relations/parent-to-one-child-relation");
+const minimal_schema_1 = require("../contracts/querying/minimal-schema");
+const relation_data_1 = require("../contracts/querying/relation-data");
+const entity_link_1 = require("../entity-link");
+const error_messages_1 = __importDefault(require("../error-messages"));
+const internal_error_1 = require("../errors/internal-error");
+const not_supported_error_1 = require("../errors/not-supported-error");
+const guard_1 = __importDefault(require("../guard"));
+const relation_resource_1 = require("../models/relation-resource");
+class RelationMapper {
+    constructor(client) {
+        guard_1.default.notNullOrUndefined(client);
+        this._client = client;
+    }
+    mapRelationsAsync(resource, schema) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.notNullOrUndefined(resource);
+            const list = [];
+            // If no minimal schema is available, build it from the definition.
+            if (schema == null) {
+                const definitionName = yield this._client.linkHelper.nameFromDefinitionAsync(resource.entityDefinition);
+                if (definitionName == null) {
+                    throw new internal_error_1.InternalError(`Could not resolve definition name from entity resource.`);
+                }
+                const definition = yield this._client.entityDefinitions.getCachedAsync(definitionName);
+                if (definition == null) {
+                    throw new internal_error_1.InternalError(`Could not load definition with name '${definitionName}.`);
+                }
+                schema = new minimal_schema_1.MinimalSchema(definitionName);
+                const loadedRelations = Object.keys(resource.relations);
+                schema.relations = definition
+                    .getRelationDefinitions()
+                    .filter(relationDefinition => loadedRelations.includes(relationDefinition.name))
+                    .map(relationDefinition => new relation_data_1.RelationData({
+                    name: relationDefinition.name,
+                    cardinality: relationDefinition.cardinality,
+                    role: relationDefinition.role,
+                }));
+            }
+            for (const relation of schema.relations) {
+                const name = relation.name;
+                const cardinality = relation.cardinality;
+                const role = relation.role;
+                // Try to get the relation, it is on the schema, so it should be there.
+                const relationObject = resource.relations[name];
+                if (!relationObject) {
+                    const msg = `[Internal] Relation with name '${relation.name}' was on schema, but not on the entity resource.`;
+                    this._client.logger.warn(msg);
+                    continue;
+                }
+                const isRelationResource = relationObject instanceof relation_resource_1.RelationResource;
+                const relationResource = relationObject;
+                // The relation should be nested, so we can use it as a RelationResource
+                if (!isRelationResource) {
+                    const msg = `[Internal] Relation with name '${relation.name}' was on the entity resource, but the relation was not nested.`;
+                    this._client.logger.warn(msg);
+                    continue;
+                }
+                let result = null;
+                if (role == relation_role_1.RelationRole.Parent) {
+                    if (cardinality == relation_cardinality_1.RelationCardinality.ManyToMany || cardinality == relation_cardinality_1.RelationCardinality.OneToMany) {
+                        const subRelation = new parent_to_many_children_relation_1.ParentToManyChildrenRelation(name);
+                        if (relationResource.children != null) {
+                            const childIds = yield this._client.linkHelper.idsFromEntitiesAsync(relationResource.children);
+                            subRelation.setIds(childIds);
+                        }
+                        result = subRelation;
+                    }
+                    else if (cardinality == relation_cardinality_1.RelationCardinality.OneToOne) {
+                        const subRelation = new parent_to_one_child_relation_1.ParentToOneChildRelation(name);
+                        if (relationResource.child != null) {
+                            const childId = yield this._client.linkHelper.idFromEntityAsync(relationResource.child);
+                            subRelation.child = childId;
+                        }
+                        else if (relationResource.children instanceof Array && relationResource.children.length) {
+                            const childId = yield this._client.linkHelper.idFromEntityAsync(relationResource.children[0]);
+                            subRelation.child = childId;
+                        }
+                        result = subRelation;
+                    }
+                }
+                else if (role == relation_role_1.RelationRole.Child) {
+                    if (cardinality == relation_cardinality_1.RelationCardinality.ManyToMany) {
+                        const subRelation = new child_to_many_parents_relation_1.ChildToManyParentsRelation(name);
+                        if (relationResource.parents != null) {
+                            const parentIds = yield this._client.linkHelper.idsFromEntitiesAsync(relationResource.parents);
+                            subRelation.setIds(parentIds);
+                        }
+                        result = subRelation;
+                    }
+                    else if (cardinality == relation_cardinality_1.RelationCardinality.OneToOne ||
+                        cardinality == relation_cardinality_1.RelationCardinality.OneToMany) {
+                        const subRelation = new child_to_one_parent_relation_1.ChildToOneParentRelation(name);
+                        if (relationResource.parent != null) {
+                            const parentId = yield this._client.linkHelper.idFromEntityAsync(relationResource.parent);
+                            subRelation.parent = parentId;
+                        }
+                        else if (relationResource.parents instanceof Array && relationResource.parents.length) {
+                            const parentId = yield this._client.linkHelper.idFromEntityAsync(relationResource.parents[0]);
+                            subRelation.parent = parentId;
+                        }
+                        result = subRelation;
+                    }
+                }
+                if (result == null) {
+                    const msg = string_format_1.default(error_messages_1.default.UnsupportedRelation, relation_cardinality_1.RelationCardinality[relation.cardinality], relation_role_1.RelationRole[relation.role]);
+                    throw new Error(msg);
+                }
+                list.push(result);
+            }
+            return list;
+        });
+    }
+    mapToRelationResourcesAsync(entity) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.notNullOrUndefined(entity);
+            return yield this.mapRelationsToResourcesAsync([...entity.relations]);
+        });
+    }
+    mapRelationToResourceAsync(relation) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.notNullOrUndefined(relation);
+            const resource = new relation_resource_1.RelationResource();
+            if (relation_1.RelationBase.isChildRelation(relation)) {
+                resource.inheritsSecurity = relation.inheritsSecurity;
+            }
+            if (relation_1.RelationBase.isChildToManyParentsRelation(relation)) {
+                const parentLinks = yield this._client.linkHelper.entitiesToLinksAsync(relation.parents);
+                resource.parents = parentLinks.map(link => new entity_link_1.EntityLink(link.href));
+            }
+            else if (relation_1.RelationBase.isChildToOneParentRelation(relation)) {
+                if (relation.parent) {
+                    const link = yield this._client.linkHelper.entityToLinkAsync(relation.parent);
+                    resource.parent = new entity_link_1.EntityLink(link.href);
+                }
+            }
+            else if (relation_1.RelationBase.isParentToManyChildrenRelation(relation)) {
+                const childLinks = yield this._client.linkHelper.entitiesToLinksAsync(relation.children);
+                resource.children = childLinks.map(link => new entity_link_1.EntityLink(link.href));
+            }
+            else if (relation_1.RelationBase.isParentToOneChildRelation(relation)) {
+                if (relation.child) {
+                    const link = yield this._client.linkHelper.entityToLinkAsync(relation.child);
+                    resource.child = new entity_link_1.EntityLink(link.href);
+                }
+            }
+            else {
+                throw new not_supported_error_1.NotSupportedError("Unknown relation type.");
+            }
+            return resource;
+        });
+    }
+    mapDirtyRelationsAsync(entity) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.notNullOrUndefined(entity);
+            const relations = entity.relations.filter(relation => relation.isDirty);
+            const dict = yield this.mapRelationsToResourcesAsync(relations);
+            return dict;
+        });
+    }
+    mapRelationsToResourcesAsync(relations) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.notNullOrUndefined(relations);
+            const dict = {};
+            for (const relation of relations) {
+                const mappedRelation = yield this.mapRelationToResourceAsync(relation);
+                if (dict[relation.name]) {
+                    const existing = dict[relation.name];
+                    const merged = relation_resource_1.RelationResource.merge(existing, mappedRelation);
+                    dict[relation.name] = merged;
+                }
+                else {
+                    dict[relation.name] = mappedRelation;
+                }
+            }
+            return dict;
+        });
+    }
+}
+exports.RelationMapper = RelationMapper;

package/dist/mappers/relation-role-mapper.d.ts

@@ -0,0 +1,5 @@
+import { RelationRole, RelationRoleType } from "../contracts/base";
+export declare class RelationRoleMapper {
+    static mapToEnumValue(value: RelationRoleType | string): RelationRole;
+    static mapToType(value: RelationRole | string): RelationRoleType;
+}

package/dist/mappers/relation-role-mapper.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RelationRoleMapper = void 0;
+const base_1 = require("../contracts/base");
+class RelationRoleMapper {
+    static mapToEnumValue(value) {
+        if (value === "Parent") {
+            return base_1.RelationRole.Parent;
+        }
+        else if (value === "Child") {
+            return base_1.RelationRole.Child;
+        }
+        else {
+            throw Error(`Can't map '${value}' to enum value.`);
+        }
+    }
+    static mapToType(value) {
+        if (value === base_1.RelationRole.Parent || value === base_1.RelationRole[base_1.RelationRole.Parent]) {
+            return "Parent";
+        }
+        else if (value === base_1.RelationRole.Child || value === base_1.RelationRole[base_1.RelationRole.Child]) {
+            return "Child";
+        }
+        else {
+            throw Error(`Can't map '${value} to type.`);
+        }
+    }
+}
+exports.RelationRoleMapper = RelationRoleMapper;

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

@@ -0,0 +1,9 @@
+import { IExtendedContentHubClient } from "../clients/extended-client";
+import { IRendition } from "../contracts/base/rendition";
+export declare class RenditionMapper {
+    private readonly _client;
+    constructor(client: IExtendedContentHubClient);
+    mapRenditions(id: number, extensionData: {
+        [key: string]: unknown;
+    }): Array<IRendition>;
+}

package/dist/mappers/rendition-mapper.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RenditionMapper = void 0;
+const rendition_1 = require("../contracts/base/rendition");
+const guard_1 = __importDefault(require("../guard"));
+const link_1 = __importDefault(require("../link"));
+class RenditionMapper {
+    constructor(client) {
+        guard_1.default.notNullOrUndefined(client);
+        this._client = client;
+    }
+    mapRenditions(id, extensionData) {
+        if (extensionData == null)
+            return [];
+        const renditions = extensionData["renditions"];
+        if (!renditions || Object.keys(renditions).length === 0)
+            return [];
+        const list = [];
+        for (const renditionName in renditions) {
+            const values = renditions[renditionName];
+            if (!values || values.length === 0)
+                continue;
+            const rendition = rendition_1.Rendition.createRendition(renditionName, values.map((value) => {
+                return link_1.default.copyFrom(value);
+            }));
+            list.push(rendition);
+        }
+        return list;
+    }
+}
+exports.RenditionMapper = RenditionMapper;

package/dist/mappers/rule-type-mapper.d.ts

@@ -0,0 +1,6 @@
+import { RuleType } from "../contracts/policies/rule-type";
+import { RuleResourceType } from "../models/policies/rule-resource";
+export declare class RuleTypeMapper {
+    static mapToRuleType(type: RuleResourceType): RuleType;
+    static mapToRuleResourceType(type: RuleType): RuleResourceType;
+}

package/dist/mappers/rule-type-mapper.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuleTypeMapper = void 0;
+const rule_type_1 = require("../contracts/policies/rule-type");
+const not_supported_error_1 = require("../errors/not-supported-error");
+const guard_1 = __importDefault(require("../guard"));
+class RuleTypeMapper {
+    static mapToRuleType(type) {
+        guard_1.default.notNull(type);
+        switch (type) {
+            case "BuiltIn":
+                return rule_type_1.RuleType.BuiltIn;
+            case "Regular":
+                return rule_type_1.RuleType.Regular;
+            default:
+                throw new not_supported_error_1.NotSupportedError("Unsupported Type");
+        }
+    }
+    static mapToRuleResourceType(type) {
+        switch (type) {
+            case rule_type_1.RuleType.BuiltIn:
+                return "BuiltIn";
+            case rule_type_1.RuleType.Regular:
+                return "Regular";
+            default:
+                throw new not_supported_error_1.NotSupportedError("Unsupported Type");
+        }
+    }
+}
+exports.RuleTypeMapper = RuleTypeMapper;

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

@@ -0,0 +1,35 @@
+import { NullableResultPromise } from "../base-types";
+import { IExtendedContentHubClient } from "../clients/extended-client";
+import { IRule } from "../contracts/policies/rule";
+import { RuleResource } from "../models/policies/rule-resource";
+export declare class RulesMapper {
+    /**
+     * Map rule resources to rules.
+     * @param client - An instance of an extended Content Hub client
+     * @param ruleResources - A collection of resources to map
+     * @returns An array of rules.
+     */
+    static mapToRulesAsync(client: IExtendedContentHubClient, ruleResources: Array<RuleResource>): Promise<Array<IRule>>;
+    /**
+     * Map a rule resource to a rule instance.
+     * @param client - An instance of an extended Content Hub client
+     * @param ruleResource - A rule resource
+     *
+     * @returns A rule or null.
+     */
+    static mapToRuleAsync(client: IExtendedContentHubClient, ruleResource: RuleResource): NullableResultPromise<IRule>;
+    /**
+     * Map rule instances to rule resources.
+     * @param client - An instance of an extended Content Hub client
+     * @param rules - A collection of rules
+     * @returns An array of rule resources.
+     */
+    static mapToRuleResourcesAsync(client: IExtendedContentHubClient, rules: Array<IRule>): Promise<Array<RuleResource>>;
+    /**
+     * Map a rule to a rule resource.
+     * @param client - An instance of an extended Content Hub client
+     * @param rule - A rule instance
+     * @returns A rule resource or null.
+     */
+    static mapToRuleResourceAsync(client: IExtendedContentHubClient, rule: IRule): NullableResultPromise<RuleResource>;
+}

package/dist/mappers/rules-mapper.js

@@ -0,0 +1,123 @@
+"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.RulesMapper = void 0;
+const rule_1 = require("../contracts/policies/rule");
+const rule_resource_1 = require("../models/policies/rule-resource");
+const condition_mapper_1 = require("./condition-mapper");
+const rule_type_mapper_1 = require("./rule-type-mapper");
+class RulesMapper {
+    /**
+     * Map rule resources to rules.
+     * @param client - An instance of an extended Content Hub client
+     * @param ruleResources - A collection of resources to map
+     * @returns An array of rules.
+     */
+    static mapToRulesAsync(client, ruleResources) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (ruleResources == null) {
+                return [];
+            }
+            const list = [];
+            for (const ruleResource of ruleResources) {
+                const rule = yield this.mapToRuleAsync(client, ruleResource);
+                if (rule != null) {
+                    list.push(rule);
+                }
+            }
+            return list;
+        });
+    }
+    /**
+     * Map a rule resource to a rule instance.
+     * @param client - An instance of an extended Content Hub client
+     * @param ruleResource - A rule resource
+     *
+     * @returns A rule or null.
+     */
+    static mapToRuleAsync(client, ruleResource) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (ruleResource == null) {
+                return null;
+            }
+            const conditions = yield condition_mapper_1.ConditionMapper.mapToConditionsAsync(client, ruleResource.conditions);
+            //TODO Decide if we need a Guid type
+            const guid = ruleResource.identifier;
+            const type = rule_type_mapper_1.RuleTypeMapper.mapToRuleType(ruleResource.type);
+            const definitionNames = yield client.linkHelper.namesFromDefinitionsAsync(ruleResource.definitions);
+            const sdkRule = new rule_1.Rule({
+                conditions: conditions,
+                createdByLoggedOnUser: ruleResource.createdByLoggedOnUser,
+                definitionNames: definitionNames.filter(name => name != null),
+                isSystemOwned: ruleResource.isSystemOwned,
+                permissions: ruleResource.permissions,
+                type: type,
+            });
+            sdkRule.setIdentifier(guid);
+            return sdkRule;
+        });
+    }
+    /**
+     * Map rule instances to rule resources.
+     * @param client - An instance of an extended Content Hub client
+     * @param rules - A collection of rules
+     * @returns An array of rule resources.
+     */
+    static mapToRuleResourcesAsync(client, rules) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (rules == null) {
+                return [];
+            }
+            const list = [];
+            for (const rule of rules) {
+                const ruleResource = yield this.mapToRuleResourceAsync(client, rule);
+                if (ruleResource != null) {
+                    list.push(ruleResource);
+                }
+            }
+            return list;
+        });
+    }
+    /**
+     * Map a rule to a rule resource.
+     * @param client - An instance of an extended Content Hub client
+     * @param rule - A rule instance
+     * @returns A rule resource or null.
+     */
+    static mapToRuleResourceAsync(client, rule) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (rule == null) {
+                return null;
+            }
+            const conditions = yield condition_mapper_1.ConditionMapper.mapToConditionResourcesAsync(client, rule.conditions);
+            const identifier = rule.identifier;
+            const permissions = rule.permissions;
+            const type = rule_type_mapper_1.RuleTypeMapper.mapToRuleResourceType(rule.type);
+            const definitionLinkTasks = [];
+            for (const definitionName of rule.definitionNames) {
+                const definitionLink = client.linkHelper.definitionToLinkAsync(definitionName);
+                definitionLinkTasks.push(definitionLink);
+            }
+            const definitionLinks = yield Promise.all(definitionLinkTasks);
+            const ruleResource = new rule_resource_1.RuleResource({
+                conditions: conditions,
+                createdByLoggedOnUser: rule.createdByLoggedOnUser,
+                definitions: definitionLinks,
+                identifier: identifier,
+                isSystemOwned: rule.isSystemOwned,
+                permissions: permissions,
+                type: type,
+            });
+            return ruleResource;
+        });
+    }
+}
+exports.RulesMapper = RulesMapper;

package/dist/mappers/typed-entity-creator.d.ts

@@ -0,0 +1,27 @@
+import { IExtendedContentHubClient } from "../clients/extended-client";
+import { Entity } from "../contracts/base/entity";
+import { EntityBase } from "../contracts/base/entity-base";
+import { EntityConstructionArgs } from "../contracts/base/entity-construction-args";
+export declare abstract class TypedEntityCreatorBase<T extends EntityBase> {
+    createTypedEntity(args: EntityConstructionArgs): T;
+    abstract createEntity(args: EntityConstructionArgs): T;
+    abstract createFile(args: EntityConstructionArgs): T;
+    abstract createAsset(args: EntityConstructionArgs): T;
+    abstract createSetting(args: EntityConstructionArgs): T;
+    abstract createUser(args: EntityConstructionArgs): T;
+    abstract createUserProfile(args: EntityConstructionArgs): T;
+    abstract createUserGroup(args: EntityConstructionArgs): T;
+    abstract createMailTemplate(args: EntityConstructionArgs): T;
+}
+export declare class TypedEntityCreator extends TypedEntityCreatorBase<Entity> {
+    private readonly _client;
+    constructor(client: IExtendedContentHubClient);
+    createEntity(args: EntityConstructionArgs): Entity;
+    createFile(args: EntityConstructionArgs): Entity;
+    createAsset(args: EntityConstructionArgs): Entity;
+    createSetting(args: EntityConstructionArgs): Entity;
+    createUser(args: EntityConstructionArgs): Entity;
+    createUserProfile(args: EntityConstructionArgs): Entity;
+    createUserGroup(args: EntityConstructionArgs): Entity;
+    createMailTemplate(args: EntityConstructionArgs): Entity;
+}

package/dist/mappers/typed-entity-creator.js

@@ -0,0 +1,76 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypedEntityCreator = exports.TypedEntityCreatorBase = void 0;
+const constants_1 = require("../constants");
+const entity_1 = require("../contracts/base/entity");
+const asset_1 = require("../contracts/content/asset");
+const guard_1 = __importDefault(require("../guard"));
+class TypedEntityCreatorBase {
+    createTypedEntity(args) {
+        guard_1.default.notNullOrUndefined(args);
+        guard_1.default.stringNotNullOrEmpty(args.definitionName);
+        let entity;
+        switch (args.definitionName) {
+            case constants_1.DEFINITIONS["Asset"].definitionName:
+                entity = this.createAsset(args);
+                break;
+            // case DEFINITIONS["File"].definitionName:
+            //     entity = this.createFile(args);
+            //     break;
+            // case DEFINITIONS["Setting"].definitionName:
+            //     entity = this.createSetting(args);
+            //     break;
+            // case DEFINITIONS["User"].definitionName:
+            //     entity = this.createUser(args);
+            //     break;
+            // case DEFINITIONS["UserGroup"].definitionName:
+            //     entity = this.createUserGroup(args);
+            //     break;
+            // case DEFINITIONS["UserProfile"].definitionName:
+            //     entity = this.createUserProfile(args);
+            //     break;
+            // case DEFINITIONS["MailTemplate"].definitionName:
+            //     entity = this.createMailTemplate(args);
+            //     break;
+            default:
+                entity = this.createEntity(args);
+                break;
+        }
+        return entity;
+    }
+}
+exports.TypedEntityCreatorBase = TypedEntityCreatorBase;
+class TypedEntityCreator extends TypedEntityCreatorBase {
+    constructor(client) {
+        super();
+        this._client = client;
+    }
+    createEntity(args) {
+        return new entity_1.Entity(this._client, args);
+    }
+    createFile(args) {
+        throw new Error("Method not implemented.");
+    }
+    createAsset(args) {
+        return new asset_1.Asset(this._client, args);
+    }
+    createSetting(args) {
+        throw new Error("Method not implemented.");
+    }
+    createUser(args) {
+        throw new Error("Method not implemented.");
+    }
+    createUserProfile(args) {
+        throw new Error("Method not implemented.");
+    }
+    createUserGroup(args) {
+        throw new Error("Method not implemented.");
+    }
+    createMailTemplate(args) {
+        throw new Error("Method not implemented.");
+    }
+}
+exports.TypedEntityCreator = TypedEntityCreator;

package/dist/models/entity-definition-collection-resource.d.ts

@@ -0,0 +1,5 @@
+import { EntityDefinitionResource } from "./entity-definition-resource";
+import { ListResource } from "./list-resource";
+export declare class EntityDefinitionCollectionResource extends ListResource<EntityDefinitionResource> {
+    items: Array<EntityDefinitionResource>;
+}

package/dist/models/entity-definition-collection-resource.js

@@ -0,0 +1,26 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityDefinitionCollectionResource = void 0;
+const ta_json_1 = require("ta-json");
+const entity_definition_resource_1 = require("./entity-definition-resource");
+const list_resource_1 = require("./list-resource");
+let EntityDefinitionCollectionResource = class EntityDefinitionCollectionResource extends list_resource_1.ListResource {
+};
+__decorate([
+    ta_json_1.JsonProperty("items"),
+    ta_json_1.JsonElementType(entity_definition_resource_1.EntityDefinitionResource),
+    __metadata("design:type", Array)
+], EntityDefinitionCollectionResource.prototype, "items", void 0);
+EntityDefinitionCollectionResource = __decorate([
+    ta_json_1.JsonObject()
+], EntityDefinitionCollectionResource);
+exports.EntityDefinitionCollectionResource = EntityDefinitionCollectionResource;

package/dist/models/entity-definition-resource.d.ts

@@ -0,0 +1,23 @@
+import { MapCultureTo } from "../base-types";
+import Link from "../link";
+import { MemberGroupResource } from "./member-group-resource";
+import Resource from "./resource";
+export declare class EntityDefinitionResource extends Resource {
+    readonly id: number;
+    name: string;
+    createdOn: Date;
+    modifiedOn: Date;
+    displayTemplate: string;
+    isTaxonomyItemDefinition: boolean;
+    isPathEnabledDefinition: boolean;
+    isManualSortingAllowed: boolean;
+    isSystemOwned: boolean;
+    labels: MapCultureTo<string>;
+    memberGroups: Array<MemberGroupResource>;
+    entities: Link;
+    relatedPaths: Link;
+    createdBy: Link;
+    modifiedBy: Link;
+    permissions: Link;
+    constructor(init?: Partial<EntityDefinitionResource>);
+}