@sitecore/sc-contenthub-webclient-sdk 1.1.1 → 1.2.1

package/README.md

@@ -4,18 +4,46 @@ Sitecore Content Hub WebClient JS SDK, which is a lightweight JS client for Site
 
 ## Internal resources
 
-- [Backlog](https://stylelabs.atlassian.net/secure/RapidBoard.jspa?rapidView=347&projectKey=ONSJSSDK&view=planning.nodetail&issueLimit=100)
-- Slack: #ch-devex-questions
+-   [Backlog](https://stylelabs.atlassian.net/secure/RapidBoard.jspa?rapidView=347&projectKey=ONSJSSDK&view=planning.nodetail&issueLimit=100)
+-   Slack: #ch-devex-questions
 
 ## Release process
 
 There are currently three build configurations that are specified in `bitbucket-pipelines.yml`
 
-- A basic build runs each time a pull request is created or updated. This is to ensure that all unit tests are passing before committing any code to `master`.
-- Once a pull request has been completed and the code is merged to `master`, an internal build is triggered automatically.
-- Public releases can be created by tagging a commit with the following: `release-<major>.<minor>.<patch>` (e.g `release-1.0.0`). Upon a successful build all artifacts are pushed to the public channels.
+-   A basic build runs each time a pull request is created or updated. This is to ensure that all unit tests are passing before committing any code to `master`.
+-   Once a pull request has been completed and the code is merged to `master`, an internal build is triggered automatically.
+-   Public releases can be created by tagging a commit with the following: `release-<major>.<minor>.<patch>` (e.g `release-1.0.0`). Upon a successful build all artifacts are pushed to the public channels.
+
+### To Release
+
+-   Add new release tag, `release-<major>.<minor>.<patch>`.
+-   Trigger a release build to publish final artifacts to the partners feed.
+-   Cut the release branch, `release\<major>.<minor>.x`.
+-   Update the Changelog in Documentation repository.
+-   Update Content Hub repository with new official released version.
+-   Bump version for the next release.
 
 ## Documentation
 
-- [Stylelabs.M.Docs reporitory](https://bitbucket.org/stylelabsdev/stylelabs.m.docs/src/master/docfx-website/content/4.0.x/integrations/javascript-sdk/)
-  *NOTE: There are multiple paths for various versions that need to be updated independently.*
+[Stylelabs.M.Docs reporitory](https://bitbucket.org/stylelabsdev/stylelabs.m.docs/src/master/docfx-website/content/4.0.x/integrations/javascript-sdk/)
+
+_NOTE: There are multiple paths for various versions that need to be updated independently._
+
+## Dev test configuration
+
+Some tests require an instance of ContentHub and a configuration to run.
+
+1. Create a .env file in project root.
+1. Configure an OAuth client in `<path-to-contenthub>/en-us/admin/oauthclients`.
+
+Example .env config:
+
+```
+ENDPOINT=https://localhost:5001
+OAUTH_CLIENT_ID=jssdk
+OAUTH_CLIENT_SECRET=testsecret
+USER_NAME=Administrator
+USER_PASSWORD=admin
+IGNORE_HTTPS_ERRORS=true
+```

package/dist/api/api-info-resource.js

@@ -18,25 +18,26 @@ const api_resource_1 = require("./api-resource");
 let ApiInfoResource = class ApiInfoResource {
 };
 __decorate([
-    ta_json_1.JsonProperty("file_version"),
-    ta_json_1.JsonConverter(file_version_converter_1.FileVersionConverter),
+    (0, ta_json_1.JsonProperty)("file_version"),
+    (0, ta_json_1.JsonConverter)(file_version_converter_1.FileVersionConverter),
     __metadata("design:type", fileversion_1.FileVersion)
 ], ApiInfoResource.prototype, "fileVersion", void 0);
 __decorate([
-    ta_json_1.JsonProperty("product_version"),
+    (0, ta_json_1.JsonProperty)("product_version"),
     __metadata("design:type", String)
 ], ApiInfoResource.prototype, "productVersion", void 0);
 __decorate([
-    ta_json_1.JsonProperty("minimum_sdk_version"),
-    ta_json_1.JsonConverter(file_version_converter_1.FileVersionConverter),
+    (0, ta_json_1.JsonProperty)("minimum_sdk_version"),
+    (0, ta_json_1.JsonConverter)(file_version_converter_1.FileVersionConverter),
     __metadata("design:type", fileversion_1.FileVersion)
 ], ApiInfoResource.prototype, "minimumSdkVersion", void 0);
 __decorate([
-    ta_json_1.JsonProperty("routes"),
-    ta_json_1.JsonConverter(api_resource_converter_1.ApiResourceConverter),
+    (0, ta_json_1.JsonProperty)("routes"),
+    (0, ta_json_1.JsonConverter)(api_resource_converter_1.ApiResourceConverter),
     __metadata("design:type", api_resource_1.ApiResource)
 ], ApiInfoResource.prototype, "routes", void 0);
 ApiInfoResource = __decorate([
-    ta_json_1.JsonObject()
+    (0, ta_json_1.JsonObject)()
 ], ApiInfoResource);
 exports.ApiInfoResource = ApiInfoResource;
+//# sourceMappingURL=api-info-resource.js.map

package/dist/api/api-info.js

@@ -12,3 +12,4 @@ class ApiInfo {
     }
 }
 exports.ApiInfo = ApiInfo;
+//# sourceMappingURL=api-info.js.map

package/dist/api/api-resource.js

@@ -11,6 +11,7 @@ const ta_json_1 = require("ta-json");
 let ApiResource = class ApiResource {
 };
 ApiResource = __decorate([
-    ta_json_1.JsonObject()
+    (0, ta_json_1.JsonObject)()
 ], ApiResource);
 exports.ApiResource = ApiResource;
+//# sourceMappingURL=api-resource.js.map

package/dist/api/api-routes-dictionary.js

@@ -8,3 +8,4 @@ exports.ApiRoutesDictionary = void 0;
 class ApiRoutesDictionary {
 }
 exports.ApiRoutesDictionary = ApiRoutesDictionary;
+//# sourceMappingURL=api-routes-dictionary.js.map

package/dist/authentication/oauth-grant-base.js

@@ -24,19 +24,20 @@ let OAuthGrantBase = class OAuthGrantBase {
     }
 };
 __decorate([
-    ta_json_1.JsonProperty("grant_type"),
+    (0, ta_json_1.JsonProperty)("grant_type"),
     __metadata("design:type", String)
 ], OAuthGrantBase.prototype, "type", void 0);
 __decorate([
-    ta_json_1.JsonProperty("client_id"),
+    (0, ta_json_1.JsonProperty)("client_id"),
     __metadata("design:type", String)
 ], OAuthGrantBase.prototype, "clientId", void 0);
 __decorate([
-    ta_json_1.JsonProperty("client_secret"),
+    (0, ta_json_1.JsonProperty)("client_secret"),
     __metadata("design:type", String)
 ], OAuthGrantBase.prototype, "clientSecret", void 0);
 OAuthGrantBase = __decorate([
-    ta_json_1.JsonObject(),
+    (0, ta_json_1.JsonObject)(),
     __metadata("design:paramtypes", [String, String])
 ], OAuthGrantBase);
 exports.OAuthGrantBase = OAuthGrantBase;
+//# sourceMappingURL=oauth-grant-base.js.map

package/dist/authentication/oauth-grant-type.js

@@ -6,3 +6,4 @@ var OAuthGrantType;
     OAuthGrantType["Password"] = "password";
     OAuthGrantType["RefreshToken"] = "refresh_token";
 })(OAuthGrantType = exports.OAuthGrantType || (exports.OAuthGrantType = {}));
+//# sourceMappingURL=oauth-grant-type.js.map

package/dist/authentication/oauth-password-grant.js

@@ -27,19 +27,20 @@ let OAuthPasswordGrant = class OAuthPasswordGrant extends oauth_grant_base_1.OAu
     }
 };
 __decorate([
-    ta_json_1.JsonProperty("grant_type"),
+    (0, ta_json_1.JsonProperty)("grant_type"),
     __metadata("design:type", String)
 ], OAuthPasswordGrant.prototype, "type", void 0);
 __decorate([
-    ta_json_1.JsonProperty("username"),
+    (0, ta_json_1.JsonProperty)("username"),
     __metadata("design:type", String)
 ], OAuthPasswordGrant.prototype, "username", void 0);
 __decorate([
-    ta_json_1.JsonProperty("password"),
+    (0, ta_json_1.JsonProperty)("password"),
     __metadata("design:type", String)
 ], OAuthPasswordGrant.prototype, "password", void 0);
 OAuthPasswordGrant = __decorate([
-    ta_json_1.JsonObject(),
+    (0, ta_json_1.JsonObject)(),
     __metadata("design:paramtypes", [String, String, String, String])
 ], OAuthPasswordGrant);
 exports.default = OAuthPasswordGrant;
+//# sourceMappingURL=oauth-password-grant.js.map

package/dist/authentication/oauth-refreshtoken-grant.js

@@ -25,15 +25,16 @@ let OAuthRefreshTokenGrant = class OAuthRefreshTokenGrant extends oauth_grant_ba
     }
 };
 __decorate([
-    ta_json_1.JsonProperty("grant_type"),
+    (0, ta_json_1.JsonProperty)("grant_type"),
     __metadata("design:type", String)
 ], OAuthRefreshTokenGrant.prototype, "type", void 0);
 __decorate([
-    ta_json_1.JsonProperty("refresh_token"),
+    (0, ta_json_1.JsonProperty)("refresh_token"),
     __metadata("design:type", String)
 ], OAuthRefreshTokenGrant.prototype, "refreshToken", void 0);
 OAuthRefreshTokenGrant = __decorate([
-    ta_json_1.JsonObject(),
+    (0, ta_json_1.JsonObject)(),
     __metadata("design:paramtypes", [String, String, String])
 ], OAuthRefreshTokenGrant);
 exports.default = OAuthRefreshTokenGrant;
+//# sourceMappingURL=oauth-refreshtoken-grant.js.map

package/dist/authentication/token-info.js

@@ -14,22 +14,23 @@ const ta_json_1 = require("ta-json");
 let TokenInfo = class TokenInfo {
 };
 __decorate([
-    ta_json_1.JsonProperty("access_token"),
+    (0, ta_json_1.JsonProperty)("access_token"),
     __metadata("design:type", String)
 ], TokenInfo.prototype, "accessToken", void 0);
 __decorate([
-    ta_json_1.JsonProperty("token_type"),
+    (0, ta_json_1.JsonProperty)("token_type"),
     __metadata("design:type", String)
 ], TokenInfo.prototype, "tokenType", void 0);
 __decorate([
-    ta_json_1.JsonProperty("refresh_token"),
+    (0, ta_json_1.JsonProperty)("refresh_token"),
     __metadata("design:type", String)
 ], TokenInfo.prototype, "refreshToken", void 0);
 __decorate([
-    ta_json_1.JsonProperty("redirect_url"),
+    (0, ta_json_1.JsonProperty)("redirect_url"),
     __metadata("design:type", String)
 ], TokenInfo.prototype, "redirectUrl", void 0);
 TokenInfo = __decorate([
-    ta_json_1.JsonObject()
+    (0, ta_json_1.JsonObject)()
 ], TokenInfo);
 exports.TokenInfo = TokenInfo;
+//# sourceMappingURL=token-info.js.map

package/dist/base-types.js

@@ -30,3 +30,4 @@ class CaseInsensitiveStringMap {
     }
 }
 exports.CaseInsensitiveStringMap = CaseInsensitiveStringMap;
+//# sourceMappingURL=base-types.js.map

package/dist/caches/culture-cache.js

@@ -19,3 +19,4 @@ class CultureCache {
     }
 }
 exports.CultureCache = CultureCache;
+//# sourceMappingURL=culture-cache.js.map

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

@@ -11,33 +11,43 @@ export declare class EntityDefinitionCache {
     /**
      * Load the specified definition into the cache.
      * @param definition - The entity definition
+     * @param includeConditionalMembers - Include conditional members
+     * @param loadPermissions - Load permissions for the definition
      */
-    load(definition: IEntityDefinition): void;
+    load(definition: IEntityDefinition, includeConditionalMembers?: boolean, loadPermissions?: boolean): void;
     /**
      * Load the specified definition into the cache asynchronously.
      * @param key - The definition name or definition id
      * @param promise - A promise resolving to the definition
+     * @param includeConditionalMembers - Include conditional members
+     * @param loadPermissions - Load permissions for the definition
      */
-    loadAsync(key: string | number, promise: NullableResultPromise<IEntityDefinition>): Promise<void>;
+    loadAsync(key: string | number, promise: NullableResultPromise<IEntityDefinition>, includeConditionalMembers?: boolean, loadPermissions?: boolean): Promise<void>;
     /**
      * Retrieve the definition with specified name or id from the cache.
      * @param key - The definition name or definition id
+     * @param includeConditionalMembers - Include conditional members
+     * @param loadPermissions - Load permissions for the definition
      * @returns The cached definition or null
      */
-    get(key: string | number): Nullable<IEntityDefinition>;
+    get(key: string | number, includeConditionalMembers?: boolean, loadPermissions?: boolean): Nullable<IEntityDefinition>;
     /**
      * Retrieve the definition with specified name or id from the cache asynchronously.
      * @param key - The definition name or definition id
+     * @param includeConditionalMembers - Include conditional members
+     * @param loadPermissions - Load permissions for the definition
      * @returns A promise resolving to the cached definition or null
      */
-    getAsync(key: string | number): Nullable<NullableResultPromise<IEntityDefinition>>;
+    getAsync(key: string | number, includeConditionalMembers?: boolean, loadPermissions?: boolean): Nullable<NullableResultPromise<IEntityDefinition>>;
     /**
      * Loads all definitions into the cache.
      * @param definitions - An array of entity definitions
      * @param loadAllIndividually - Flag indicating whether to load the definitions individually or not
      * @param loadAsGroup - Key to be used to store the array of definitions, or false to not load the array
+     * @param includeConditionalMembers - Include conditional members
+     * @param loadPermissions - Load permissions for the definitions
      */
-    loadAll(definitions: Array<IEntityDefinition>, loadAllIndividually?: boolean, loadAsGroup?: false | string): void;
+    loadAll(definitions: Array<IEntityDefinition>, loadAllIndividually?: boolean, loadAsGroup?: false | string, includeConditionalMembers?: boolean, loadPermissions?: boolean): void;
     /**
      * Retrieves an array of definitions that was cached with the specified group key.
      *
@@ -45,13 +55,17 @@ export declare class EntityDefinitionCache {
      * Can not be used to retrieve a single cached definition. Use {@link EntityDefinitionCache.get} instead.
      *
      * @param group - The key with which the group of definitions was stored
+     * @param includeConditionalMembers - Include conditional members
+     * @param loadPermissions - Load permissions for the definitions
      */
-    getAll(group?: string): Nullable<Array<IEntityDefinition>>;
+    getAll(group?: string, includeConditionalMembers?: boolean, loadPermissions?: boolean): Nullable<Array<IEntityDefinition>>;
     /**
      * Invalidates/removes the definition with specified name or id from the cache.
      * @param key - The definition name or definition id
+     * @param includeConditionalMembers - Include conditional members
+     * @param loadPermissions - Load permissions for the definition
      */
-    invalidate(key?: string | number): void;
+    invalidate(key?: string | number, includeConditionalMembers?: boolean, loadPermissions?: boolean): void;
     private validateKey;
     private getCacheKey;
 }

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

@@ -18,22 +18,26 @@ class EntityDefinitionCache {
     /**
      * Load the specified definition into the cache.
      * @param definition - The entity definition
+     * @param includeConditionalMembers - Include conditional members
+     * @param loadPermissions - Load permissions for the definition
      */
-    load(definition) {
+    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), definition);
-        this._map.set(definition.id.toString(), 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.
      * @param key - The definition name or definition id
      * @param promise - A promise resolving to the definition
+     * @param includeConditionalMembers - Include conditional members
+     * @param loadPermissions - Load permissions for the definition
      */
-    loadAsync(key, promise) {
+    loadAsync(key, promise, includeConditionalMembers, loadPermissions) {
         this.validateKey(key);
         guard_1.default.notNullOrUndefined(promise);
-        this._map.set(`${this._promiseKeyPrefix}${this.getCacheKey(key.toString())}`, promise);
+        this._map.set(`${this._promiseKeyPrefix}${this.getCacheKey(key.toString(), includeConditionalMembers, loadPermissions)}`, promise);
         const loadPromise = promise.then(definition => {
             if (definition) {
                 this.load(definition);
@@ -44,26 +48,30 @@ class EntityDefinitionCache {
     /**
      * Retrieve the definition with specified name or id from the cache.
      * @param key - The definition name or definition id
+     * @param includeConditionalMembers - Include conditional members
+     * @param loadPermissions - Load permissions for the definition
      * @returns The cached definition or null
      */
-    get(key) {
+    get(key, includeConditionalMembers, loadPermissions) {
         this.validateKey(key);
-        const res = this._map.get(this.getCacheKey(key.toString())) || null;
+        const res = this._map.get(this.getCacheKey(key.toString(), includeConditionalMembers, loadPermissions)) || null;
         return res;
     }
     /**
      * Retrieve the definition with specified name or id from the cache asynchronously.
      * @param key - The definition name or definition id
+     * @param includeConditionalMembers - Include conditional members
+     * @param loadPermissions - Load permissions for the definition
      * @returns A promise resolving to the cached definition or null
      */
-    getAsync(key) {
+    getAsync(key, includeConditionalMembers, loadPermissions) {
         this.validateKey(key);
-        const promise = (this._map.get(`${this._promiseKeyPrefix}${this.getCacheKey(key.toString())}`) ||
-            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())) || null);
+        const definition = (this.get(this.getCacheKey(key.toString(), includeConditionalMembers, loadPermissions)) ||
+            null);
         if (definition != null) {
             return Promise.resolve(definition);
         }
@@ -74,18 +82,20 @@ class EntityDefinitionCache {
      * @param definitions - An array of entity definitions
      * @param loadAllIndividually - Flag indicating whether to load the definitions individually or not
      * @param loadAsGroup - Key to be used to store the array of definitions, or false to not load the array
+     * @param includeConditionalMembers - Include conditional members
+     * @param loadPermissions - Load permissions for the definitions
      */
-    loadAll(definitions, loadAllIndividually = true, loadAsGroup = this._allCacheKey) {
+    loadAll(definitions, loadAllIndividually = true, loadAsGroup = this._allCacheKey, includeConditionalMembers, loadPermissions) {
         guard_1.default.notNullOrUndefined(definitions);
         if (definitions.length === 0) {
             return;
         }
         if (loadAsGroup) {
             guard_1.default.stringNotNullOrEmpty(loadAsGroup);
-            this._map.set(this.getCacheKey(loadAsGroup), definitions);
+            this._map.set(this.getCacheKey(loadAsGroup, includeConditionalMembers, loadPermissions), definitions);
         }
         if (loadAllIndividually) {
-            definitions.forEach(this.load, this);
+            definitions.forEach(definition => this.load(definition, includeConditionalMembers, loadPermissions), this);
         }
     }
     /**
@@ -95,16 +105,20 @@ class EntityDefinitionCache {
      * Can not be used to retrieve a single cached definition. Use {@link EntityDefinitionCache.get} instead.
      *
      * @param group - The key with which the group of definitions was stored
+     * @param includeConditionalMembers - Include conditional members
+     * @param loadPermissions - Load permissions for the definitions
      */
-    getAll(group = this._allCacheKey) {
-        const res = this._map.get(this.getCacheKey(group)) || null;
+    getAll(group = this._allCacheKey, includeConditionalMembers, loadPermissions) {
+        const res = this._map.get(this.getCacheKey(group, includeConditionalMembers, loadPermissions)) || null;
         return res instanceof Array ? res : null;
     }
     /**
      * Invalidates/removes the definition with specified name or id from the cache.
      * @param key - The definition name or definition id
+     * @param includeConditionalMembers - Include conditional members
+     * @param loadPermissions - Load permissions for the definition
      */
-    invalidate(key) {
+    invalidate(key, includeConditionalMembers, loadPermissions) {
         if (!key) {
             this._map.clear();
             return;
@@ -113,8 +127,8 @@ class EntityDefinitionCache {
         const definition = this.get(key);
         if (!definition)
             return;
-        this._map.delete(this.getCacheKey(definition.name));
-        this._map.delete(definition.id.toString());
+        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") {
@@ -124,8 +138,11 @@ class EntityDefinitionCache {
             guard_1.default.validId(key);
         }
     }
-    getCacheKey(key) {
-        return key.trim().toLowerCase();
+    getCacheKey(key, includeConditionalMembers, loadPermissions) {
+        return [key.trim().toLowerCase(), includeConditionalMembers && "conditionals", loadPermissions && "permissions"]
+            .filter(Boolean)
+            .join("-");
     }
 }
 exports.EntityDefinitionCache = EntityDefinitionCache;
+//# sourceMappingURL=entity-definition-cache.js.map

package/dist/clients/aggregates-client.d.ts

@@ -1,19 +1,43 @@
 import CultureInfo from "../culture-info";
 import { AggregateResource } from "../models/aggregate-resources/aggregate-resource";
 import { IExtendedContentHubClient } from "./extended-client";
+import { CancelCallback } from "./internal-client";
+export interface AggregateLoadOption {
+    /**
+     *  Flag for loading option lists. Defaults to true.
+     */
+    loadOptionLists?: boolean;
+    /**
+     * Flag for loading settings. Defaults to true.
+     */
+    loadSettings?: boolean;
+    /**
+     * Flag for loading definitions. Defaults to true.
+     */
+    loadDefinitions?: boolean;
+    /**
+     * Flag for loading entities. Defaults to true.
+     */
+    loadEntities?: boolean;
+    /**
+     * Flag for loading permissions. If not defined, will not be added to the query.
+     */
+    loadPermissions?: boolean;
+}
 export interface IAggregateClient {
     /**
      * Method for getting the specified aggregate for the specified entity.
      * @param name - The name of the aggregate
      * @param id - The entity id to get the aggregate for
      * @param culture - The user culture
-     * @param loadPermissions - Flag for loading permissions
+     * @param loadOptions - Can optionally configure what needs to be loaded from the aggregates (everything will be loaded by default except for permissions)
+     * @param cancelCallback - A {@link CancelCallback} that will be placed in an Axios {@link CancelToken} if provided
      * @returns An aggregate resource
      */
-    getAsync(name: string, id: number, culture?: CultureInfo, loadPermissions?: boolean): Promise<AggregateResource>;
+    getAsync(name: string, id: number, culture?: CultureInfo, loadOptions?: AggregateLoadOption, cancelCallback?: CancelCallback): Promise<AggregateResource>;
 }
 export declare class AggregateClient implements IAggregateClient {
     private readonly _client;
     constructor(client: IExtendedContentHubClient);
-    getAsync(name: string, id: number, culture?: CultureInfo, loadPermissions?: boolean): Promise<AggregateResource>;
+    getAsync(name: string, id: number, culture?: CultureInfo, loadOptions?: AggregateLoadOption, cancelCallback?: CancelCallback): Promise<AggregateResource>;
 }

package/dist/clients/aggregates-client.js

@@ -22,14 +22,15 @@ class AggregateClient {
         guard_1.default.notNull(client);
         this._client = client;
     }
-    getAsync(name, id, culture, loadPermissions) {
+    getAsync(name, id, culture, loadOptions = {}, cancelCallback) {
         return __awaiter(this, void 0, void 0, function* () {
             guard_1.default.stringNotNullOrEmpty(name);
-            const link = yield this._client.linkHelper.aggregateToLinkAsync(name, id, culture, loadPermissions);
-            const response = yield this._client.raw.getAsync(link.href);
+            const link = yield this._client.linkHelper.aggregateToLinkAsync(name, id, culture, loadOptions);
+            const response = yield this._client.raw.getAsync(link.href, undefined, cancelCallback);
             response_handler_1.ResponseHandler.handleErrors(response);
             return ta_json_1.TaJson.deserialize(response.content, aggregate_resource_1.AggregateResource);
         });
     }
 }
 exports.AggregateClient = AggregateClient;
+//# sourceMappingURL=aggregates-client.js.map

package/dist/clients/api-client.js

@@ -91,10 +91,10 @@ class ApiClient {
             if (!this.disableCompatibilityChecks) {
                 const compatibilityResult = this._client.versionChecker.getCompatibility(serverVersion, sdkVersion, resource.minimumSdkVersion);
                 if (compatibilityResult == compatibility_1.Compatibility.SdkOld) {
-                    throw new not_supported_error_1.NotSupportedError(string_format_1.default(error_messages_1.default.ContentHubClient.IncompatibleMinimumVersion, sdkVersion, serverVersion, resource.minimumSdkVersion));
+                    throw new not_supported_error_1.NotSupportedError((0, string_format_1.default)(error_messages_1.default.ContentHubClient.IncompatibleMinimumVersion, sdkVersion, serverVersion, resource.minimumSdkVersion));
                 }
                 if (compatibilityResult == compatibility_1.Compatibility.SdkNew) {
-                    throw new not_supported_error_1.NotSupportedError(string_format_1.default(error_messages_1.default.ContentHubClient.IncompatibleVersion, sdkVersion, serverVersion));
+                    throw new not_supported_error_1.NotSupportedError((0, string_format_1.default)(error_messages_1.default.ContentHubClient.IncompatibleVersion, sdkVersion, serverVersion));
                 }
             }
             const apiInfo = api_resource_mapper_1.ApiResourceMapper.map(resource);
@@ -103,3 +103,4 @@ class ApiClient {
     }
 }
 exports.ApiClient = ApiClient;
+//# sourceMappingURL=api-client.js.map

package/dist/clients/assets-client.d.ts

@@ -0,0 +1,16 @@
+import { IExtendedContentHubClient } from "./extended-client";
+/**
+ * Allows fetching culture information.
+ */
+export interface IAssetsClient {
+    /**
+     * Gets the default culture.
+     * @returns The default culture.
+     */
+    createPublicLinkAsync(assetId: number, rendition: string, expirationDate?: Date, relativeUrl?: string): Promise<number>;
+}
+export declare class AssetsClient implements IAssetsClient {
+    private readonly _client;
+    constructor(client: IExtendedContentHubClient);
+    createPublicLinkAsync(assetId: number, rendition: string, expirationDate?: Date, relativeUrl?: string): Promise<number>;
+}

package/dist/clients/assets-client.js

@@ -0,0 +1,43 @@
+"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.AssetsClient = void 0;
+const definitions_1 = require("../constants/definitions");
+const guard_1 = __importDefault(require("../guard"));
+class AssetsClient {
+    constructor(client) {
+        guard_1.default.notNull(client);
+        this._client = client;
+    }
+    createPublicLinkAsync(assetId, rendition, expirationDate, relativeUrl) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.validId(assetId);
+            guard_1.default.stringNotNullOrEmpty(rendition);
+            const publicLink = yield this._client.entityFactory.createAsync(definitions_1.PublicLink.definitionName);
+            publicLink.setPropertyValue(definitions_1.PublicLink.resource, rendition);
+            if (expirationDate) {
+                publicLink.setPropertyValue(definitions_1.PublicLink.expirationDate, expirationDate);
+            }
+            if (relativeUrl) {
+                guard_1.default.stringNotNullOrEmpty(relativeUrl);
+                publicLink.setPropertyValue(definitions_1.PublicLink.relativeUrl, relativeUrl);
+            }
+            const assetToPublicLink = publicLink.getRelation(definitions_1.PublicLink.assetToPublicLink);
+            assetToPublicLink === null || assetToPublicLink === void 0 ? void 0 : assetToPublicLink.add(assetId);
+            return this._client.entities.saveAsync(publicLink);
+        });
+    }
+}
+exports.AssetsClient = AssetsClient;
+//# sourceMappingURL=assets-client.js.map

package/dist/clients/commands-client.d.ts

@@ -1,4 +1,5 @@
 import { IExtendedContentHubClient } from "./extended-client";
+import { CancelCallback } from "./internal-client";
 import { ResponseMessage } from "./response-message";
 export interface ICommandsClient {
     /**
@@ -6,21 +7,23 @@ export interface ICommandsClient {
      * @param namespace - The name of the folder containing the command
      * @param command - The name of the command
      * @param args - The arguments of the command or null/undefined if the command has no arguments
+     * @param cancelCallback - A {@link CancelCallback} that will be placed in an Axios {@link CancelToken} if provided
      * @returns The raw HTTP response.
      */
-    executeCommandRawAsync(namespace: string, command: string, args?: unknown): Promise<ResponseMessage<unknown>>;
+    executeCommandRawAsync(namespace: string, command: string, args?: unknown, cancelCallback?: CancelCallback): Promise<ResponseMessage<unknown>>;
     /**
      * Executes a Content Hub command.
      * @param namespace - The name of the folder containing the command
      * @param command - The name of the command
      * @param args - The arguments of the command or null/undefined if the command has no arguments
+     * @param cancelCallback - A {@link CancelCallback} that will be placed in an Axios {@link CancelToken} if provided
      * @returns The result of the command. If the command has no result, null is returned.
      */
-    executeCommandAsync(namespace: string, command: string, args?: unknown): Promise<unknown>;
+    executeCommandAsync(namespace: string, command: string, args?: unknown, cancelCallback?: CancelCallback): Promise<unknown>;
 }
 export declare class CommandsClient implements ICommandsClient {
     private readonly _client;
     constructor(client: IExtendedContentHubClient);
-    executeCommandRawAsync(namespace: string, command: string, args?: unknown): Promise<ResponseMessage<unknown>>;
-    executeCommandAsync(namespace: string, command: string, args?: unknown): Promise<unknown>;
+    executeCommandRawAsync(namespace: string, command: string, args?: unknown, cancelCallback?: CancelCallback): Promise<ResponseMessage<unknown>>;
+    executeCommandAsync(namespace: string, command: string, args?: unknown, cancelCallback?: CancelCallback): Promise<unknown>;
 }