@sitecore/sc-contenthub-webclient-sdk 1.2.6 → 1.2.12

package/dist/caches/entity-definition-cache.d.ts

@@ -1,5 +1,6 @@
 import { Nullable, NullableResultPromise } from "../base-types";
 import { IEntityDefinition } from "../contracts/base";
+import { ViewMode } from "../contracts/base/view-mode";
 /**
  * Caches definition in memory.
  */
@@ -47,7 +48,7 @@ export declare class EntityDefinitionCache {
      * @param includeConditionalMembers - Include conditional members
      * @param loadPermissions - Load permissions for the definitions
      */
-    loadAll(definitions: Array<IEntityDefinition>, loadAllIndividually?: boolean, loadAsGroup?: false | string, includeConditionalMembers?: boolean, loadPermissions?: boolean): void;
+    loadAll(definitions: Array<IEntityDefinition>, loadAllIndividually?: boolean, loadAsGroup?: false | string, includeConditionalMembers?: boolean, loadPermissions?: boolean, viewMode?: ViewMode, excludeTaxonomyDefinitions?: boolean, excludeSystemOwnedDefinitions?: boolean, filter?: string, definitionsToLoadByName?: string, definitionsToLoadById?: string): void;
     /**
      * Retrieves an array of definitions that was cached with the specified group key.
      *
@@ -58,7 +59,7 @@ export declare class EntityDefinitionCache {
      * @param includeConditionalMembers - Include conditional members
      * @param loadPermissions - Load permissions for the definitions
      */
-    getAll(group?: string, includeConditionalMembers?: boolean, loadPermissions?: boolean): Nullable<Array<IEntityDefinition>>;
+    getAll(group?: string, includeConditionalMembers?: boolean, loadPermissions?: boolean, viewMode?: ViewMode, excludeTaxonomyDefinitions?: boolean, excludeSystemOwnedDefinitions?: boolean, filter?: string, definitionsToLoadByName?: string, definitionsToLoadById?: string): Nullable<Array<IEntityDefinition>>;
     /**
      * Invalidates/removes the definition with specified name or id from the cache.
      * @param key - The definition name or definition id

package/dist/caches/entity-definition-cache.js

@@ -24,8 +24,8 @@ class EntityDefinitionCache {
     load(definition, includeConditionalMembers, loadPermissions) {
         guard_1.default.notNullOrUndefined(definition, "definition");
         guard_1.default.notNullOrUndefined(definition.id, "definition id");
-        this._map.set(this.getCacheKey(definition.name, includeConditionalMembers, loadPermissions), definition);
-        this._map.set(this.getCacheKey(definition.id.toString(), includeConditionalMembers, loadPermissions), definition);
+        this._map.set(this.getCacheKey(definition.name, { includeConditionalMembers, loadPermissions }), definition);
+        this._map.set(this.getCacheKey(definition.id.toString(), { includeConditionalMembers, loadPermissions }), definition);
     }
     /**
      * Load the specified definition into the cache asynchronously.
@@ -37,7 +37,10 @@ class EntityDefinitionCache {
     loadAsync(key, promise, includeConditionalMembers, loadPermissions) {
         this.validateKey(key);
         guard_1.default.notNullOrUndefined(promise);
-        this._map.set(`${this._promiseKeyPrefix}${this.getCacheKey(key.toString(), includeConditionalMembers, loadPermissions)}`, promise);
+        this._map.set(`${this._promiseKeyPrefix}${this.getCacheKey(key.toString(), {
+            includeConditionalMembers,
+            loadPermissions,
+        })}`, promise);
         const loadPromise = promise.then(definition => {
             if (definition) {
                 this.load(definition);
@@ -54,7 +57,7 @@ class EntityDefinitionCache {
      */
     get(key, includeConditionalMembers, loadPermissions) {
         this.validateKey(key);
-        const res = this._map.get(this.getCacheKey(key.toString(), includeConditionalMembers, loadPermissions)) || null;
+        const res = this._map.get(this.getCacheKey(key.toString(), { includeConditionalMembers, loadPermissions })) || null;
         return res;
     }
     /**
@@ -66,12 +69,14 @@ class EntityDefinitionCache {
      */
     getAsync(key, includeConditionalMembers, loadPermissions) {
         this.validateKey(key);
-        const promise = (this._map.get(`${this._promiseKeyPrefix}${this.getCacheKey(key.toString(), includeConditionalMembers, loadPermissions)}`) || null);
+        const promise = (this._map.get(`${this._promiseKeyPrefix}${this.getCacheKey(key.toString(), {
+            includeConditionalMembers,
+            loadPermissions,
+        })}`) || null);
         if (promise != null) {
             return promise;
         }
-        const definition = (this.get(this.getCacheKey(key.toString(), includeConditionalMembers, loadPermissions)) ||
-            null);
+        const definition = (this.get(this.getCacheKey(key.toString(), { includeConditionalMembers, loadPermissions })) || null);
         if (definition != null) {
             return Promise.resolve(definition);
         }
@@ -85,14 +90,23 @@ class EntityDefinitionCache {
      * @param includeConditionalMembers - Include conditional members
      * @param loadPermissions - Load permissions for the definitions
      */
-    loadAll(definitions, loadAllIndividually = true, loadAsGroup = this._allCacheKey, includeConditionalMembers, loadPermissions) {
+    loadAll(definitions, loadAllIndividually = true, loadAsGroup = this._allCacheKey, includeConditionalMembers, loadPermissions, viewMode, excludeTaxonomyDefinitions, excludeSystemOwnedDefinitions, filter, definitionsToLoadByName, definitionsToLoadById) {
         guard_1.default.notNullOrUndefined(definitions);
         if (definitions.length === 0) {
             return;
         }
         if (loadAsGroup) {
             guard_1.default.stringNotNullOrEmpty(loadAsGroup);
-            this._map.set(this.getCacheKey(loadAsGroup, includeConditionalMembers, loadPermissions), definitions);
+            this._map.set(this.getCacheKey(loadAsGroup, {
+                filter,
+                definitionsToLoadByName,
+                definitionsToLoadById,
+                viewMode,
+                loadPermissions,
+                includeConditionalMembers,
+                excludeTaxonomyDefinitions,
+                excludeSystemOwnedDefinitions,
+            }), definitions);
         }
         if (loadAllIndividually) {
             definitions.forEach(definition => this.load(definition, includeConditionalMembers, loadPermissions), this);
@@ -108,8 +122,17 @@ class EntityDefinitionCache {
      * @param includeConditionalMembers - Include conditional members
      * @param loadPermissions - Load permissions for the definitions
      */
-    getAll(group = this._allCacheKey, includeConditionalMembers, loadPermissions) {
-        const res = this._map.get(this.getCacheKey(group, includeConditionalMembers, loadPermissions)) || null;
+    getAll(group = this._allCacheKey, includeConditionalMembers, loadPermissions, viewMode, excludeTaxonomyDefinitions, excludeSystemOwnedDefinitions, filter, definitionsToLoadByName, definitionsToLoadById) {
+        const res = this._map.get(this.getCacheKey(group, {
+            filter,
+            definitionsToLoadByName,
+            definitionsToLoadById,
+            viewMode,
+            loadPermissions,
+            includeConditionalMembers,
+            excludeTaxonomyDefinitions,
+            excludeSystemOwnedDefinitions,
+        })) || null;
         return res instanceof Array ? res : null;
     }
     /**
@@ -127,8 +150,8 @@ class EntityDefinitionCache {
         const definition = this.get(key);
         if (!definition)
             return;
-        this._map.delete(this.getCacheKey(definition.name, includeConditionalMembers, loadPermissions));
-        this._map.delete(this.getCacheKey(definition.id.toString(), includeConditionalMembers, loadPermissions));
+        this._map.delete(this.getCacheKey(definition.name, { includeConditionalMembers, loadPermissions }));
+        this._map.delete(this.getCacheKey(definition.id.toString(), { includeConditionalMembers, loadPermissions }));
     }
     validateKey(key) {
         if (typeof key === "string") {
@@ -138,8 +161,18 @@ class EntityDefinitionCache {
             guard_1.default.validId(key);
         }
     }
-    getCacheKey(key, includeConditionalMembers, loadPermissions) {
-        return [key.trim().toLowerCase(), includeConditionalMembers && "conditionals", loadPermissions && "permissions"]
+    getCacheKey(key, { filter, definitionsToLoadByName, definitionsToLoadById, viewMode, loadPermissions, includeConditionalMembers, excludeTaxonomyDefinitions, excludeSystemOwnedDefinitions, }) {
+        return [
+            key.trim().toLowerCase(),
+            includeConditionalMembers && "conditionals",
+            loadPermissions && "permissions",
+            viewMode,
+            excludeTaxonomyDefinitions && "excludeTaxonomyDefinitions",
+            excludeSystemOwnedDefinitions && "excludeSystemOwnedDefinitions",
+            filter,
+            definitionsToLoadByName,
+            definitionsToLoadById,
+        ]
             .filter(Boolean)
             .join("-");
     }

package/dist/clients/entity-definitions-client.d.ts

@@ -1,5 +1,6 @@
 import { MapNumberTo, MapStringTo, NullableResultPromise } from "../base-types";
 import { IEntityDefinition } from "../contracts/base/entity-definition";
+import { ViewMode } from "../contracts/base/view-mode";
 import { IEntityDefinitionIterator } from "../contracts/querying/entity-definition-iterator";
 import { IEntityDefinitionQueryResult } from "../contracts/querying/entity-definition-query-result";
 import { IIdIterator } from "../contracts/querying/id-iterator";
@@ -28,16 +29,28 @@ export interface IEntityDefinitionsClient {
      * Get all the {@link IEntityDefinition}s.
      * @param includeConditionalMembers - Include conditional members
      * @param loadPermissions - Load permissions for the definitions
+     * @param viewMode - Select appropriate ViewMode
+     * @param loadPermissions - Load permissions for the definitions
+     * @param excludeTaxonomyDefinitions - Exclude taxonomy definitions from the result
+     * @param excludeSystemOwnedDefinitions - Exclude system owned definitions from the result
+     * @param filter - Additional filters
+     * @param definitionsToLoadByName - Comma separated list of definition names
+     * @param definitionsToLoadById - Comma separated list of definition identifiers
      * @returns Promise which resolved to an array of {@link IEntityDefinition}s.
      */
-    getAllAsync(includeConditionalMembers?: boolean, loadPermissions?: boolean): Promise<Array<IEntityDefinition>>;
+    getAllAsync(includeConditionalMembers?: boolean, loadPermissions?: boolean, viewMode?: ViewMode, excludeTaxonomyDefinitions?: boolean, excludeSystemOwnedDefinitions?: boolean, filter?: string, definitionsToLoadByName?: string, definitionsToLoadById?: string): Promise<Array<IEntityDefinition>>;
     /**
      * Get all the {@link IEntityDefinition}s (cached).
      * @param includeConditionalMembers - Include conditional members
      * @param loadPermissions - Load permissions for the definitions
+     * @param excludeTaxonomyDefinitions - Exclude taxonomy definitions from the result
+     * @param excludeSystemOwnedDefinitions - Exclude system owned definitions from the result
+     * @param filter - Additional filters
+     * @param definitionsToLoadByName - Comma separated list of definition names
+     * @param definitionsToLoadById - Comma separated list of definition identifiers
      * @returns Promise which resolved to an array of {@link IEntityDefinition}s.
      */
-    getAllCachedAsync(includeConditionalMembers?: boolean, loadPermissions?: boolean): Promise<Array<IEntityDefinition>>;
+    getAllCachedAsync(includeConditionalMembers?: boolean, loadPermissions?: boolean, viewMode?: ViewMode, excludeTaxonomyDefinitions?: boolean, excludeSystemOwnedDefinitions?: boolean, filter?: string, definitionsToLoadByName?: string, definitionsToLoadById?: string): Promise<Array<IEntityDefinition>>;
     /**
      * Get the cached {@link IEntityDefinition} instance by the specified name.
      * @param name - The name of the definition
@@ -101,8 +114,8 @@ export declare class EntityDefinitionsClient implements IEntityDefinitionsClient
     private readonly _client;
     private readonly _cache;
     constructor(client: IExtendedContentHubClient);
-    getAllCachedAsync(includeConditionalMembers?: boolean, loadPermissions?: boolean): Promise<Array<IEntityDefinition>>;
-    getAllAsync(includeConditionalMembers?: boolean, loadPermissions?: boolean): Promise<Array<IEntityDefinition>>;
+    getAllCachedAsync(includeConditionalMembers?: boolean, loadPermissions?: boolean, viewMode?: ViewMode, excludeTaxonomyDefinitions?: boolean, excludeSystemOwnedDefinitions?: boolean, filter?: string, definitionsToLoadByName?: string, definitionsToLoadById?: string): Promise<Array<IEntityDefinition>>;
+    getAllAsync(includeConditionalMembers?: boolean, loadPermissions?: boolean, viewMode?: ViewMode, excludeTaxonomyDefinitions?: boolean, excludeSystemOwnedDefinitions?: boolean, filter?: string, definitionsToLoadByName?: string, definitionsToLoadById?: string): Promise<Array<IEntityDefinition>>;
     getAsync(param: string | number, includeConditionalMembers?: boolean, loadPermissions?: boolean, cacheSignature?: string): NullableResultPromise<IEntityDefinition>;
     getCachedAsync(param: string | number, includeConditionalMembers?: boolean, loadPermissions?: boolean, cacheSignature?: string): NullableResultPromise<IEntityDefinition>;
     getNameAsync(id: number, cacheSignature?: string): NullableResultPromise<string>;

package/dist/clients/entity-definitions-client.js

@@ -17,6 +17,7 @@ const http_status_codes_1 = require("http-status-codes");
 const ta_json_1 = require("ta-json");
 const urijs_1 = __importDefault(require("urijs"));
 const entity_definition_cache_1 = require("../caches/entity-definition-cache");
+const api_1 = require("../constants/api");
 const entity_definition_id_iterator_1 = require("../contracts/querying/entity-definition-id-iterator");
 const entity_definition_id_query_result_1 = require("../contracts/querying/entity-definition-id-query-result");
 const entity_definition_iterator_1 = require("../contracts/querying/entity-definition-iterator");
@@ -28,25 +29,24 @@ const entity_definition_resource_1 = require("../models/entity-definition-resour
 const type_guards_1 = require("../type-guards");
 const array_utilities_1 = require("../utilities/array-utilities");
 const response_handler_1 = require("./response-handler");
-const api_1 = require("../constants/api");
 class EntityDefinitionsClient {
     constructor(client) {
         this._client = client;
         this._cache = new entity_definition_cache_1.EntityDefinitionCache();
     }
-    getAllCachedAsync(includeConditionalMembers = true, loadPermissions) {
+    getAllCachedAsync(includeConditionalMembers = true, loadPermissions, viewMode, excludeTaxonomyDefinitions, excludeSystemOwnedDefinitions, filter, definitionsToLoadByName, definitionsToLoadById) {
         return __awaiter(this, void 0, void 0, function* () {
-            let definitions = this._cache.getAll(undefined, includeConditionalMembers, loadPermissions);
+            let definitions = this._cache.getAll(undefined, includeConditionalMembers, loadPermissions, viewMode, excludeTaxonomyDefinitions, excludeSystemOwnedDefinitions, filter, definitionsToLoadByName, definitionsToLoadById);
             if (!definitions) {
-                definitions = yield this.getAllAsync(includeConditionalMembers, loadPermissions);
+                definitions = yield this.getAllAsync(includeConditionalMembers, loadPermissions, viewMode, excludeTaxonomyDefinitions, excludeSystemOwnedDefinitions, filter, definitionsToLoadByName, definitionsToLoadById);
             }
             return definitions;
         });
     }
-    getAllAsync(includeConditionalMembers = true, loadPermissions) {
+    getAllAsync(includeConditionalMembers = true, loadPermissions, viewMode, excludeTaxonomyDefinitions, excludeSystemOwnedDefinitions, filter, definitionsToLoadByName, definitionsToLoadById) {
         return __awaiter(this, void 0, void 0, function* () {
-            const allEntityDefinitions = yield this.getAllBatchedAsync(includeConditionalMembers, loadPermissions);
-            this._cache.loadAll(allEntityDefinitions, undefined, undefined, includeConditionalMembers, loadPermissions);
+            const allEntityDefinitions = yield this.getAllBatchedAsync(includeConditionalMembers, loadPermissions, viewMode, excludeTaxonomyDefinitions, excludeSystemOwnedDefinitions, filter, definitionsToLoadByName, definitionsToLoadById);
+            this._cache.loadAll(allEntityDefinitions, undefined, undefined, includeConditionalMembers, loadPermissions, viewMode, excludeTaxonomyDefinitions, excludeSystemOwnedDefinitions, filter, definitionsToLoadByName, definitionsToLoadById);
             return allEntityDefinitions;
         });
     }
@@ -334,14 +334,14 @@ class EntityDefinitionsClient {
             return Promise.all(definitions).then(results => results.filter((result) => result != null));
         });
     }
-    getAllBatchedAsync(includeConditionalMembers = true, loadPermissions) {
+    getAllBatchedAsync(includeConditionalMembers = true, loadPermissions, viewMode, excludeTaxonomyDefinitions, excludeSystemOwnedDefinitions, filter, definitionsToLoadByName, definitionsToLoadById) {
         var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
             const resources = [];
             let resource = null;
             let skip = 0;
             while (resource == null || resource.next) {
-                const link = (_a = resource === null || resource === void 0 ? void 0 : resource.next) !== null && _a !== void 0 ? _a : (yield this._client.linkHelper.definitionsLinkAsync(skip, EntityDefinitionsClient._batchSize, includeConditionalMembers, undefined, loadPermissions));
+                const link = (_a = resource === null || resource === void 0 ? void 0 : resource.next) !== null && _a !== void 0 ? _a : (yield this._client.linkHelper.definitionsLinkAsync(skip, EntityDefinitionsClient._batchSize, includeConditionalMembers, viewMode, loadPermissions, excludeTaxonomyDefinitions, excludeSystemOwnedDefinitions, filter, definitionsToLoadByName, definitionsToLoadById));
                 const response = yield this._client.raw.getAsync(link.href);
                 response_handler_1.ResponseHandler.handleErrors(response);
                 resource = ta_json_1.TaJson.deserialize(response.content, entity_definition_collection_resource_1.EntityDefinitionCollectionResource);

package/dist/contracts/base/entity-base.d.ts

@@ -25,6 +25,7 @@ export declare abstract class EntityBase implements IEntity {
     id?: number;
     identifier: Nullable<string>;
     hasPublicLink?: boolean;
+    masterFileModifiedOn?: Date;
     gatewayLinks?: Record<string, Link>;
     publicLink?: string;
     publicCollectionLink?: string;

package/dist/contracts/base/entity-base.js

@@ -300,6 +300,10 @@ __decorate([
     (0, ta_json_1.JsonProperty)("hasPublicLink"),
     __metadata("design:type", Boolean)
 ], EntityBase.prototype, "hasPublicLink", void 0);
+__decorate([
+    (0, ta_json_1.JsonProperty)("masterFileModifiedOn"),
+    __metadata("design:type", Date)
+], EntityBase.prototype, "masterFileModifiedOn", void 0);
 __decorate([
     (0, ta_json_1.JsonProperty)("gatewayLinks"),
     __metadata("design:type", Object)

package/dist/contracts/base/entity.d.ts

@@ -91,6 +91,10 @@ export interface IEntity extends IResource, IDirtyTracking {
      * Gets or sets a value indicating whether this entity has at least one public link.
      */
     hasPublicLink?: boolean;
+    /**
+     * Gets the modification date of the related MasterFile entity.
+     */
+    masterFileModifiedOn?: Date;
     /**
      * The name of the page that the saved selection should redirect too.
      */

package/dist/link-helper.d.ts

@@ -1,9 +1,9 @@
+import { AggregateLoadOption } from "clients/aggregates-client";
 import { Nullable, NullableResultPromise } from "./base-types";
 import { IExtendedContentHubClient } from "./clients/extended-client";
 import { ViewMode } from "./contracts/base/view-mode";
 import CultureInfo from "./culture-info";
 import Link from "./link";
-import { AggregateLoadOption } from "clients/aggregates-client";
 export interface ILinkHelper {
     /**
      * Extracts the name of a data source from the specified link.
@@ -96,7 +96,7 @@ export interface ILinkHelper {
      * @param excludeSystemOwnedDefinitions - [Optional] Exclude system owned definitions from the result
      * @returns Link to the entity definitions included in this batch.
      */
-    definitionsLinkAsync(skip?: number, take?: number, includeConditionalMembers?: boolean, viewMode?: ViewMode, loadPermissions?: boolean, excludeTaxonomyDefinitions?: boolean, excludeSystemOwnedDefinitions?: boolean): Promise<Link>;
+    definitionsLinkAsync(skip?: number, take?: number, includeConditionalMembers?: boolean, viewMode?: ViewMode, loadPermissions?: boolean, excludeTaxonomyDefinitions?: boolean, excludeSystemOwnedDefinitions?: boolean, filter?: string, definitionsToLoadByName?: string, definitionsToLoadById?: string): Promise<Link>;
     relationToLinkAsync(id: number, name: string): Promise<Link>;
     /**
      * Extracts the id of an entity from the specified link.
@@ -218,7 +218,7 @@ export declare class LinkHelper implements ILinkHelper {
     definitionToLinkAsync(param: string | number, includeConditionalMembers?: boolean, loadPermissions?: boolean): Promise<Link>;
     definitionToLinkV2Async(name: string, includeConditionalMembers?: boolean, loadPermissions?: boolean): Promise<Link>;
     definitionsToLinkAsync(values: Nullable<Array<string>> | Nullable<Array<number>>, skip?: number, take?: number, includeConditionalMembers?: boolean, viewMode?: ViewMode, loadPermissions?: boolean, excludeTaxonomyDefinitions?: boolean, excludeSystemOwnedDefinitions?: boolean): Promise<Link>;
-    definitionsLinkAsync(skip?: number, take?: number, includeConditionalMembers?: boolean, viewMode?: ViewMode, loadPermissions?: boolean, excludeTaxonomyDefinitions?: boolean, excludeSystemOwnedDefinitions?: boolean): Promise<Link>;
+    definitionsLinkAsync(skip?: number, take?: number, includeConditionalMembers?: boolean, viewMode?: ViewMode, loadPermissions?: boolean, excludeTaxonomyDefinitions?: boolean, excludeSystemOwnedDefinitions?: boolean, filter?: string, definitionsToLoadByName?: string, definitionsToLoadById?: string): Promise<Link>;
     idFromEntityAsync(link: Link): Promise<number | null>;
     idsFromEntitiesAsync(links: Array<Link>): Promise<Array<number>>;
     entityToLinkAsync(param: number | string, culture?: Nullable<CultureInfo>): Promise<Link>;
@@ -236,7 +236,7 @@ export declare class LinkHelper implements ILinkHelper {
     commandToLinkAsync(namespace: string, command: string): Promise<Link>;
     sendConfirmationMailToLinkAsync(userId: number): Promise<Link>;
     sendNotificationToLinkAsync(notificationType: string): Promise<Link>;
-    aggregateToLinkAsync(aggregateName: string, entityId: number, culture?: CultureInfo, { loadPermissions, loadOptionLists, loadSettings, loadEntities, loadDefinitions }?: AggregateLoadOption): Promise<Link>;
+    aggregateToLinkAsync(aggregateName: string, entityId: number, culture?: CultureInfo, { loadPermissions, loadOptionLists, loadSettings, loadEntities, loadDefinitions, }?: AggregateLoadOption): Promise<Link>;
     pageResourceToLinkAsync(page: string | number, culture: CultureInfo, entityId?: number): Promise<Link>;
     searchLinkAsync(): Promise<Readonly<Link>>;
     allFacetsAsync(): Promise<Readonly<Link>>;

package/dist/link-helper.js

@@ -139,7 +139,7 @@ class LinkHelper {
             return yield this.bindAsync(api_1.ENTITY_DEFINITIONS.templateName, variables);
         });
     }
-    definitionsLinkAsync(skip, take, includeConditionalMembers, viewMode, loadPermissions, excludeTaxonomyDefinitions, excludeSystemOwnedDefinitions) {
+    definitionsLinkAsync(skip, take, includeConditionalMembers, viewMode, loadPermissions, excludeTaxonomyDefinitions, excludeSystemOwnedDefinitions, filter, definitionsToLoadByName, definitionsToLoadById) {
         return __awaiter(this, void 0, void 0, function* () {
             const variables = LinkHelper.applyEntityDefinitionVariables({
                 skip,
@@ -149,6 +149,9 @@ class LinkHelper {
                 loadPermissions,
                 excludeTaxonomyDefinitions,
                 excludeSystemOwnedDefinitions,
+                filter,
+                definitionsToLoadByName,
+                definitionsToLoadById,
             });
             return yield this.bindAsync(api_1.ENTITY_DEFINITIONS.templateName, variables);
         });
@@ -326,7 +329,7 @@ class LinkHelper {
     }
     //#endregion
     //#region Aggregates
-    aggregateToLinkAsync(aggregateName, entityId, culture, { loadPermissions, loadOptionLists = true, loadSettings = true, loadEntities = true, loadDefinitions = true } = {}) {
+    aggregateToLinkAsync(aggregateName, entityId, culture, { loadPermissions, loadOptionLists = true, loadSettings = true, loadEntities = true, loadDefinitions = true, } = {}) {
         return __awaiter(this, void 0, void 0, function* () {
             guard_1.default.stringNotNullOrEmpty(aggregateName);
             guard_1.default.validId(entityId);

package/dist/mappers/entity-mapper.js

@@ -127,6 +127,7 @@ class EntityMapper {
                 isCurrentUserDefault: entity.isCurrentUserDefault,
                 languageSupportedOotb: entity.languageSupportedOotb,
                 hasPublicLink: entity.hasPublicLink,
+                masterFileModifiedOn: entity.masterFileModifiedOn,
                 savedSelectionPageName: entity.savedSelectionPageName,
                 gatewayLinks: entity.gatewayLinks,
                 publicLink: entity.publicLink,
@@ -171,6 +172,7 @@ class EntityMapper {
             entity.isCurrentUserDefault = resource.isCurrentUserDefault;
             entity.languageSupportedOotb = resource.languageSupportedOotb;
             entity.hasPublicLink = resource.hasPublicLink;
+            entity.masterFileModifiedOn = resource.masterFileModifiedOn;
             entity.savedSelectionPageName = resource.savedSelectionPageName;
             entity.gatewayLinks = resource.gatewayLinks;
             entity.publicLink = resource.publicLink;

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

@@ -35,6 +35,7 @@ export declare class EntityResource extends Resource {
     isCurrentUserDefault?: boolean;
     languageSupportedOotb?: boolean;
     hasPublicLink?: boolean;
+    masterFileModifiedOn?: Date;
     savedSelectionPageName?: string;
     gatewayLinks?: Record<string, Link>;
     publicLink?: string;

package/dist/models/entity-resource.js

@@ -151,6 +151,10 @@ __decorate([
     (0, ta_json_1.JsonProperty)("HasPublicLink"),
     __metadata("design:type", Boolean)
 ], EntityResource.prototype, "hasPublicLink", void 0);
+__decorate([
+    (0, ta_json_1.JsonProperty)("masterFileModifiedOn"),
+    __metadata("design:type", Date)
+], EntityResource.prototype, "masterFileModifiedOn", void 0);
 __decorate([
     (0, ta_json_1.JsonProperty)("saved_selection_page_name"),
     __metadata("design:type", String)

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@sitecore/sc-contenthub-webclient-sdk",
-    "version": "1.2.6",
+    "version": "1.2.12",
     "description": "Sitecore Content Hub WebClient SDK.",
     "scripts": {
         "build": "npm run clean && npm run test && tsc && npm run lint",
@@ -10,11 +10,12 @@
         "test": "jest --forceExit --verbose --detectOpenHandles --coverage",
         "watch-test": "npm run test -- --watchAll",
         "clean": "rimraf dist/",
-        "version": "echo $npm_package_version"
+        "bump-version": "npm version --no-git-tag-version --force",
+        "pack": "npm pack --pack-destination ./artifacts"
     },
     "repository": {
         "type": "git",
-        "url": "bitbucket.org/stylelabsdev/sitecore.ch.sdk.javascript.git"
+        "url": "github.com/Sitecore-PD/sitecore.contenthub.cli"
     },
     "keywords": [
         "sitecore",
@@ -22,30 +23,17 @@
         "contenthub"
     ],
     "author": "Sitecore",
-    "contributors": [
-        {
-            "name": "James Pas",
-            "email": "james.pas@sitecore.com"
-        },
-        {
-            "name": "Wouter Govaert",
-            "email": "wouter.govaert@sitecore.com"
-        },
-        {
-            "name": "Maxime Antoine",
-            "email": "maxime.antoine@sitecore.com"
-        }
-    ],
+    "license": "SEE LICENSE IN Sitecore.Artifact.License.Agreement.md",
     "files": [
         "/dist/**/*.d.ts",
         "/dist/**/*.js"
     ],
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
-    "license": "MIT",
     "dependencies": {
         "axios": "^0.24.0",
         "axios-extensions": "^3.1.3",
+        "form-data": "^4.0.0",
         "http-status-codes": "^2.1.4",
         "ow": "^0.28.1",
         "string-format": "^2.0.0",

package/LICENSE

@@ -1,24 +0,0 @@
-MIT License
------------
-
-Copyright (c) 2019 Sitecore
-Permission is hereby granted, free of charge, to any person
-obtaining a copy of this software and associated documentation
-files (the "Software"), to deal in the Software without
-restriction, including without limitation the rights to use,
-copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the
-Software is furnished to do so, subject to the following
-conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
-OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-OTHER DEALINGS IN THE SOFTWARE.