@sitecore/sc-contenthub-webclient-sdk 1.1.0 → 1.2.0

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

@@ -7,28 +7,75 @@ import { Query } from "../contracts/querying/query";
 import { IQueryLoadConfiguration } from "../contracts/querying/query-load-configuration";
 import { IContentHubClient } from "./content-hub-client";
 import { IExtendedContentHubClient } from "./extended-client";
+import { CancelCallback } from "./internal-client";
 export interface IQueryingClient {
-    singleAsync(query: Query, loadConfiguration?: IEntityLoadConfiguration): NullableResultPromise<IEntity>;
-    singleIdAsync(query: Query): NullableResultPromise<number>;
-    queryAsync(query: Query): Promise<IEntityQueryResult>;
-    queryAsync(query: Query, loadConfiguration?: Nullable<IEntityLoadConfiguration>): Promise<IEntityQueryResult>;
-    queryIdsAsync(query: Query): Promise<IIdQueryResult>;
+    singleAsync(query: Query, loadConfiguration?: IEntityLoadConfiguration, cancelCallback?: CancelCallback): NullableResultPromise<IEntity>;
+    singleIdAsync(query: Query, cancelCallback?: CancelCallback): NullableResultPromise<number>;
+    queryAsync(query: Query, loadConfiguration?: Nullable<IEntityLoadConfiguration>, cancelCallback?: CancelCallback): Promise<IEntityQueryResult>;
+    queryIdsAsync(query: Query, cancelCallback?: CancelCallback): Promise<IIdQueryResult>;
 }
+/**
+ *  Contains functionality to query and scroll for entities.
+ */
 declare abstract class QueryingClientBase implements IQueryingClient {
     protected readonly _client: IContentHubClient;
     constructor(client: IContentHubClient);
-    singleAsync(query: Query, loadConfiguration?: IEntityLoadConfiguration): NullableResultPromise<IEntity>;
-    singleIdAsync(query: Query): NullableResultPromise<number>;
-    abstract queryAsync(query: Query, loadConfiguration?: Nullable<IEntityLoadConfiguration>): Promise<IEntityQueryResult>;
-    abstract queryIdsAsync(query: Query): Promise<IIdQueryResult>;
+    /**
+     * Gets a single entity that matches the query.
+     *
+     * @param query - The query to execute
+     * @param loadConfiguration - The load configuration. If it is null, then {@link EntityLoadConfiguration#Default} will be used.
+     * @param cancelCallback - A {@link CancelCallback} that will be placed in an Axios {@link CancelToken} if provided
+     * @returns The entity that matches the query or null if there are no results.
+     */
+    singleAsync(query: Query, loadConfiguration?: IEntityLoadConfiguration, cancelCallback?: CancelCallback): NullableResultPromise<IEntity>;
+    /**
+     * Gets a the id of the entity that matches the query.
+     *
+     * @param query - The query to execute
+     * @param cancelCallback - A {@link CancelCallback} that will be placed in an Axios {@link CancelToken} if provided
+     * @returns The id of the entity that matches the query or null if there are no results.
+     */
+    singleIdAsync(query: Query, cancelCallback?: CancelCallback): NullableResultPromise<number>;
+    /**
+     * Retrieves entities matching the query.
+     *
+     * @param query - The query to execute.
+     * @param loadConfiguration - The load configuration. If it is null, then {@link EntityLoadConfiguration#Default} will be used.
+     * @param cancelCallback - A {@link CancelCallback} that will be placed in an Axios {@link CancelToken} if provided
+     */
+    abstract queryAsync(query: Query, loadConfiguration?: Nullable<IEntityLoadConfiguration>, cancelCallback?: CancelCallback): Promise<IEntityQueryResult>;
+    /**
+     * Retrieves the ids of entities matching the query.
+     *
+     * @param query - The query to execute.
+     * @param cancelCallback - A {@link CancelCallback} that will be placed in an Axios {@link CancelToken} if provided
+     */
+    abstract queryIdsAsync(query: Query, cancelCallback?: CancelCallback): Promise<IIdQueryResult>;
     protected resolveLoadConfiguration(query: Query, loadConfiguration?: IEntityLoadConfiguration): Nullable<IQueryLoadConfiguration>;
 }
+/**
+ *  Contains functionality to query and scroll for entities.
+ */
 export declare class QueryingClient extends QueryingClientBase {
     private readonly _extendedClient;
     private readonly _mapper;
     private readonly _schemaQuerying;
     constructor(client: IExtendedContentHubClient);
-    queryAsync(query: Query, loadConfiguration?: Nullable<IEntityLoadConfiguration>): Promise<IEntityQueryResult>;
-    queryIdsAsync(query: Query): Promise<IIdQueryResult>;
+    /**
+     * Retrieves entities matching the query.
+     *
+     * @param query - The query to execute.
+     * @param loadConfiguration - The load configuration. If it is null, then {@link EntityLoadConfiguration#Default} will be used.
+     * @param cancelCallback - A {@link CancelCallback} that will be placed in an Axios {@link CancelToken} if provided
+     */
+    queryAsync(query: Query, loadConfiguration?: Nullable<IEntityLoadConfiguration>, cancelCallback?: CancelCallback): Promise<IEntityQueryResult>;
+    /**
+     * Retrieves the ids of entities matching the query.
+     *
+     * @param query - The query to execute.
+     * @param cancelCallback - A {@link CancelCallback} that will be placed in an Axios {@link CancelToken} if provided
+     */
+    queryIdsAsync(query: Query, cancelCallback?: CancelCallback): Promise<IIdQueryResult>;
 }
 export {};

package/dist/clients/querying-client.js

@@ -20,15 +20,26 @@ const guard_1 = __importDefault(require("../guard"));
 const load_options_mapper_1 = require("../mappers/load-options-mapper");
 const querying_mapper_1 = require("../mappers/querying-mapper");
 const schema_querying_1 = require("./schema-querying");
+/**
+ *  Contains functionality to query and scroll for entities.
+ */
 class QueryingClientBase {
     constructor(client) {
         guard_1.default.notNullOrUndefined(client);
         this._client = client;
     }
-    singleAsync(query, loadConfiguration) {
+    /**
+     * Gets a single entity that matches the query.
+     *
+     * @param query - The query to execute
+     * @param loadConfiguration - The load configuration. If it is null, then {@link EntityLoadConfiguration#Default} will be used.
+     * @param cancelCallback - A {@link CancelCallback} that will be placed in an Axios {@link CancelToken} if provided
+     * @returns The entity that matches the query or null if there are no results.
+     */
+    singleAsync(query, loadConfiguration, cancelCallback) {
         return __awaiter(this, void 0, void 0, function* () {
             guard_1.default.notNullOrUndefined(query);
-            const result = yield this.queryAsync(query, loadConfiguration);
+            const result = yield this.queryAsync(query, loadConfiguration, cancelCallback);
             if (result.items.length === 0) {
                 return null;
             }
@@ -38,10 +49,17 @@ class QueryingClientBase {
             return result.items[0];
         });
     }
-    singleIdAsync(query) {
+    /**
+     * Gets a the id of the entity that matches the query.
+     *
+     * @param query - The query to execute
+     * @param cancelCallback - A {@link CancelCallback} that will be placed in an Axios {@link CancelToken} if provided
+     * @returns The id of the entity that matches the query or null if there are no results.
+     */
+    singleIdAsync(query, cancelCallback) {
         return __awaiter(this, void 0, void 0, function* () {
             guard_1.default.notNullOrUndefined(query);
-            const result = yield this.queryIdsAsync(query);
+            const result = yield this.queryIdsAsync(query, cancelCallback);
             if (result.items.length === 0) {
                 return null;
             }
@@ -63,6 +81,9 @@ class QueryingClientBase {
         return queryLoadConfiguration;
     }
 }
+/**
+ *  Contains functionality to query and scroll for entities.
+ */
 class QueryingClient extends QueryingClientBase {
     constructor(client) {
         super(client);
@@ -71,25 +92,39 @@ class QueryingClient extends QueryingClientBase {
         this._schemaQuerying = new schema_querying_1.SchemaQuerying(client);
         this._mapper = new querying_mapper_1.QueryingMapper(client);
     }
-    queryAsync(query, loadConfiguration) {
+    /**
+     * Retrieves entities matching the query.
+     *
+     * @param query - The query to execute.
+     * @param loadConfiguration - The load configuration. If it is null, then {@link EntityLoadConfiguration#Default} will be used.
+     * @param cancelCallback - A {@link CancelCallback} that will be placed in an Axios {@link CancelToken} if provided
+     */
+    queryAsync(query, loadConfiguration, cancelCallback) {
         return __awaiter(this, void 0, void 0, function* () {
             guard_1.default.notNullOrUndefined(query, "query");
             //TODO query.validate();
             const queryLoadConfiguration = this.resolveLoadConfiguration(query, loadConfiguration || undefined);
-            const resource = yield this._schemaQuerying.queryWithSchemaAsync(query, queryLoadConfiguration);
+            const resource = yield this._schemaQuerying.queryWithSchemaAsync(query, queryLoadConfiguration, cancelCallback);
             loadConfiguration = load_options_mapper_1.LoadOptionsMapper.toEntityLoadConfiguration(queryLoadConfiguration || undefined);
             const result = yield this._mapper.mapEntityQueryResultAsync(resource, query, loadConfiguration);
             return result;
         });
     }
-    queryIdsAsync(query) {
+    /**
+     * Retrieves the ids of entities matching the query.
+     *
+     * @param query - The query to execute.
+     * @param cancelCallback - A {@link CancelCallback} that will be placed in an Axios {@link CancelToken} if provided
+     */
+    queryIdsAsync(query, cancelCallback) {
         return __awaiter(this, void 0, void 0, function* () {
             guard_1.default.notNullOrUndefined(query, "query");
             //TODO query.validate();
-            const resource = yield this._schemaQuerying.queryWithSchemaAsync(query, query_load_configuration_1.QueryLoadConfiguration.Ids);
+            const resource = yield this._schemaQuerying.queryWithSchemaAsync(query, query_load_configuration_1.QueryLoadConfiguration.Ids, cancelCallback);
             const result = yield this._mapper.mapEntityIdQueryResultAsync(resource, query);
             return result;
         });
     }
 }
 exports.QueryingClient = QueryingClient;
+//# sourceMappingURL=querying-client.js.map

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

@@ -1,29 +1,22 @@
 import URI from "urijs";
 import { MapStringTo } from "../base-types";
 import { IExtendedContentHubClient } from "./extended-client";
+import { CancelCallback } from "./internal-client";
 import { RequestMessage } from "./request-message";
 import { ResponseMessage } from "./response-message";
 export interface IRawClient {
-    getAsync<T>(uri: string, headers?: MapStringTo<string>): Promise<ResponseMessage<T>>;
-    getAsync<T>(uri: URI, headers?: MapStringTo<string>): Promise<ResponseMessage<T>>;
-    getAsync<T>(uri: string | URI, headers?: MapStringTo<string>): Promise<ResponseMessage<T>>;
-    postAsync<T, K>(uri: string, content?: T, headers?: MapStringTo<string>): Promise<ResponseMessage<K>>;
-    postAsync<T, K>(uri: URI, content?: T, headers?: MapStringTo<string>): Promise<ResponseMessage<K>>;
-    postAsync<T, K>(uri: string | URI, content?: T, headers?: MapStringTo<string>): Promise<ResponseMessage<K>>;
-    putAsync<T, K>(uri: string, content?: T, headers?: MapStringTo<string>): Promise<ResponseMessage<K>>;
-    putAsync<T, K>(uri: URI, content?: T, headers?: MapStringTo<string>): Promise<ResponseMessage<K>>;
-    putAsync<T, K>(uri: string | URI, content?: T, headers?: MapStringTo<string>): Promise<ResponseMessage<K>>;
-    deleteAsync<T>(uri: string, headers?: MapStringTo<string>): Promise<ResponseMessage<T>>;
-    deleteAsync<T>(uri: URI, headers?: MapStringTo<string>): Promise<ResponseMessage<T>>;
-    deleteAsync<T>(uri: string | URI, headers?: MapStringTo<string>): Promise<ResponseMessage<T>>;
-    sendAsync<T, K>(messageFactory: () => RequestMessage): Promise<ResponseMessage<K>>;
+    getAsync<T>(uri: string | URI, headers?: MapStringTo<string>, cancelCallback?: CancelCallback): Promise<ResponseMessage<T>>;
+    postAsync<T, K>(uri: string | URI, content?: T, headers?: MapStringTo<string>, cancelCallback?: CancelCallback): Promise<ResponseMessage<K>>;
+    putAsync<T, K>(uri: string | URI, content?: T, headers?: MapStringTo<string>, cancelCallback?: CancelCallback): Promise<ResponseMessage<K>>;
+    deleteAsync<T>(uri: string | URI, headers?: MapStringTo<string>, cancelCallback?: CancelCallback): Promise<ResponseMessage<T>>;
+    sendAsync<T, K>(messageFactory: () => RequestMessage, cancelCallback?: CancelCallback): Promise<ResponseMessage<K>>;
 }
 export declare class RawClient implements IRawClient {
     private readonly _client;
     constructor(client: IExtendedContentHubClient);
-    getAsync<T = any>(uri: string | URI, headers?: MapStringTo<string>): Promise<ResponseMessage<T>>;
-    postAsync<T = any, K = any>(uri: string | URI, content: unknown, headers?: MapStringTo<string>): Promise<ResponseMessage<K>>;
-    putAsync<T = any, K = any>(uri: string | URI, content: unknown, headers?: MapStringTo<string>): Promise<ResponseMessage<K>>;
-    deleteAsync<T = any>(uri: string | URI, headers?: MapStringTo<string>): Promise<ResponseMessage<T>>;
-    sendAsync<T = any, K = any>(messageFactory: () => RequestMessage<T>): Promise<ResponseMessage<K>>;
+    getAsync<T = any>(uri: string | URI, headers?: MapStringTo<string>, cancelCallback?: CancelCallback): Promise<ResponseMessage<T>>;
+    postAsync<T = any, K = any>(uri: string | URI, content: unknown, headers?: MapStringTo<string>, cancelCallback?: CancelCallback): Promise<ResponseMessage<K>>;
+    putAsync<T = any, K = any>(uri: string | URI, content: unknown, headers?: MapStringTo<string>, cancelCallback?: CancelCallback): Promise<ResponseMessage<K>>;
+    deleteAsync<T = any>(uri: string | URI, headers?: MapStringTo<string>, cancelCallback?: CancelCallback): Promise<ResponseMessage<T>>;
+    sendAsync<T = any, K = any>(messageFactory: () => RequestMessage<T>, cancelCallback?: CancelCallback): Promise<ResponseMessage<K>>;
 }

package/dist/clients/raw-client.js

@@ -22,16 +22,16 @@ class RawClient {
         guard_1.default.notNullOrUndefined(client);
         this._client = client;
     }
-    getAsync(uri, headers) {
+    getAsync(uri, headers, cancelCallback) {
         return __awaiter(this, void 0, void 0, function* () {
             return yield this._client.internalClient.sendAsync(() => new request_message_1.RequestMessage({
                 requestUri: uri,
                 method: http_method_1.HttpMethod.GET,
                 requestHeaders: headers,
-            }));
+            }), cancelCallback);
         });
     }
-    postAsync(uri, content, headers) {
+    postAsync(uri, content, headers, cancelCallback) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!headers) {
                 headers = {
@@ -43,10 +43,10 @@ class RawClient {
                 method: http_method_1.HttpMethod.POST,
                 requestHeaders: headers,
                 content: content,
-            }));
+            }), cancelCallback);
         });
     }
-    putAsync(uri, content, headers) {
+    putAsync(uri, content, headers, cancelCallback) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!headers) {
                 headers = {
@@ -58,23 +58,24 @@ class RawClient {
                 method: http_method_1.HttpMethod.PUT,
                 requestHeaders: headers,
                 content: content,
-            }));
+            }), cancelCallback);
         });
     }
-    deleteAsync(uri, headers) {
+    deleteAsync(uri, headers, cancelCallback) {
         return __awaiter(this, void 0, void 0, function* () {
             return yield this._client.internalClient.sendAsync(() => new request_message_1.RequestMessage({
                 requestUri: uri,
                 method: http_method_1.HttpMethod.DELETE,
                 requestHeaders: headers,
-            }));
+            }), cancelCallback);
         });
     }
-    sendAsync(messageFactory) {
+    sendAsync(messageFactory, cancelCallback) {
         return __awaiter(this, void 0, void 0, function* () {
             guard_1.default.notNullOrUndefined(messageFactory);
-            return yield this._client.internalClient.sendAsync(messageFactory);
+            return yield this._client.internalClient.sendAsync(messageFactory, cancelCallback);
         });
     }
 }
 exports.RawClient = RawClient;
+//# sourceMappingURL=raw-client.js.map

package/dist/clients/request-message.js

@@ -11,3 +11,4 @@ class RequestMessage {
     }
 }
 exports.RequestMessage = RequestMessage;
+//# sourceMappingURL=request-message.js.map

package/dist/clients/response-handler.js

@@ -1,29 +1,10 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ResponseHandler = void 0;
-const HttpStatus = __importStar(require("http-status-codes"));
+const http_status_codes_1 = require("http-status-codes");
 const argument_error_1 = require("../errors/argument-error");
 const forbidden_error_1 = require("../errors/forbidden-error");
 const not_found_error_1 = require("../errors/not-found-error");
@@ -45,7 +26,7 @@ class ResponseHandler {
         if (responseMessage.isSuccessStatusCode) {
             return;
         }
-        if (responseMessage.statusCode === HttpStatus.BAD_REQUEST) {
+        if (responseMessage.statusCode === http_status_codes_1.StatusCodes.BAD_REQUEST) {
             ResponseHandler.handleBadRequest(responseMessage);
         }
         else {
@@ -65,7 +46,7 @@ class ResponseHandler {
         if (responseMessage.isSuccessStatusCode) {
             throw new argument_error_1.ArgumentError(`Can not process successful request (code: ${responseMessage.statusCode}).`);
         }
-        if (responseMessage.statusCode !== HttpStatus.BAD_REQUEST) {
+        if (responseMessage.statusCode !== http_status_codes_1.StatusCodes.BAD_REQUEST) {
             throw new argument_error_1.ArgumentError(`Can not process failed request with status code '${responseMessage.statusCode}'.`);
         }
         /* istanbul ignore if */
@@ -123,18 +104,18 @@ class ResponseHandler {
             catch (ex) { }
         }
         message = message !== null && message !== void 0 ? message : responseMessage.content;
-        if (responseMessage.statusCode === HttpStatus.FORBIDDEN) {
+        if (responseMessage.statusCode === http_status_codes_1.StatusCodes.FORBIDDEN) {
             throw new forbidden_error_1.ForbiddenError(message !== null && message !== void 0 ? message : "Insufficient privileges or resource in use.");
         }
-        else if (responseMessage.statusCode === HttpStatus.NOT_FOUND) {
-            throw new not_found_error_1.NotFoundError(message !== null && message !== void 0 ? message : "Resource can not be found.", responseMessage);
+        else if (responseMessage.statusCode === http_status_codes_1.StatusCodes.NOT_FOUND) {
+            throw new not_found_error_1.NotFoundError(message && message.length > 0 ? message : "Resource can not be found.", responseMessage);
         }
         else {
             if (message != null) {
                 message =
                     `An error has occurred (${responseMessage.statusCode}${responseMessage.statusText != null ? ` - ${responseMessage.statusText}` : ""}).\n` + `Message: ${message}`;
             }
-            else if (responseMessage.statusCode === HttpStatus.CONFLICT) {
+            else if (responseMessage.statusCode === http_status_codes_1.StatusCodes.CONFLICT) {
                 message = `Conflict in the parameter value or name (${responseMessage.statusCode}${responseMessage.statusText != null ? ` - ${responseMessage.statusText}` : ""})`;
             }
             else {
@@ -145,3 +126,4 @@ class ResponseHandler {
     }
 }
 exports.ResponseHandler = ResponseHandler;
+//# sourceMappingURL=response-handler.js.map

package/dist/clients/response-message.js

@@ -32,3 +32,4 @@ class ResponseMessage {
     }
 }
 exports.ResponseMessage = ResponseMessage;
+//# sourceMappingURL=response-message.js.map

package/dist/clients/schema-querying.d.ts

@@ -3,14 +3,15 @@ import { IQueryLoadConfiguration } from "../contracts/querying/query-load-config
 import { ScrollRequest } from "../contracts/querying/scroll-request";
 import { QueryResultResource } from "../models/query-result-resource";
 import { IExtendedContentHubClient } from "./extended-client";
+import { CancelCallback } from "./internal-client";
 export interface ISchemaQuerying {
-    queryWithSchemaAsync(query: Query, loadConfiguration: IQueryLoadConfiguration): Promise<QueryResultResource>;
-    scrollWithSchemaAsync(scrollRequest: ScrollRequest): Promise<QueryResultResource>;
+    queryWithSchemaAsync(query: Query, loadConfiguration: IQueryLoadConfiguration, cancelCallback?: CancelCallback): Promise<QueryResultResource>;
+    scrollWithSchemaAsync(scrollRequest: ScrollRequest, cancelCallback?: CancelCallback): Promise<QueryResultResource>;
 }
 export declare class SchemaQuerying implements ISchemaQuerying {
     private readonly _client;
     constructor(client: IExtendedContentHubClient);
-    queryWithSchemaAsync(query: Query, loadConfiguration: IQueryLoadConfiguration): Promise<QueryResultResource>;
+    queryWithSchemaAsync(query: Query, loadConfiguration: IQueryLoadConfiguration, cancelCallback?: CancelCallback): Promise<QueryResultResource>;
     scrollWithSchemaAsync(scrollRequest: ScrollRequest): Promise<QueryResultResource>;
     private queryEndpointAsync;
 }

package/dist/clients/schema-querying.js

@@ -26,7 +26,7 @@ class SchemaQuerying {
         guard_1.default.notNullOrUndefined(client);
         this._client = client;
     }
-    queryWithSchemaAsync(query, loadConfiguration) {
+    queryWithSchemaAsync(query, loadConfiguration, cancelCallback) {
         return __awaiter(this, void 0, void 0, function* () {
             guard_1.default.notNullOrUndefined(query, "query");
             guard_1.default.notNullOrUndefined(loadConfiguration, "loadConfiguration");
@@ -46,22 +46,23 @@ class SchemaQuerying {
                 query: query,
                 loadConfiguration: loadConfiguration,
             });
-            const resource = yield this.queryEndpointAsync(uri, ta_json_1.TaJson.serialize(queryRequest));
+            const resource = yield this.queryEndpointAsync(uri, ta_json_1.TaJson.serialize(queryRequest), cancelCallback);
             return resource;
         });
     }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
     scrollWithSchemaAsync(scrollRequest) {
         return __awaiter(this, void 0, void 0, function* () {
             throw new Error("Method not implemented."); //TODO
         });
     }
-    queryEndpointAsync(endpoint, content) {
+    queryEndpointAsync(endpoint, content, cancelCallback) {
         return __awaiter(this, void 0, void 0, function* () {
             const response = yield this._client.raw.postAsync(endpoint, content, {
                 [api_1.HEADERS.apiVersion]: "3",
                 [api_1.HEADERS.minimalSchema]: "true",
                 "Content-Type": "application/json",
-            });
+            }, cancelCallback);
             response_handler_1.ResponseHandler.handleErrors(response);
             const resource = ta_json_1.TaJson.deserialize(response.content, query_result_resource_1.QueryResultResource);
             return resource;
@@ -69,3 +70,4 @@ class SchemaQuerying {
     }
 }
 exports.SchemaQuerying = SchemaQuerying;
+//# sourceMappingURL=schema-querying.js.map

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

@@ -3,23 +3,26 @@ import { AllFacetsRequest } from "../models/search/all-facets-request";
 import { SearchRequest } from "../models/search/search-request";
 import { SearchResponse } from "../models/search/search-response";
 import { IExtendedContentHubClient } from "./extended-client";
+import { CancelCallback } from "./internal-client";
 export interface ISearchClient {
     /**
      * Send a {@link SearchRequest}.
      * @param searchRequest - The search request
+     * @param cancelCallback - A {@link CancelCallback} that will be placed in an axios {@link CancelToken} if provided
      * @returns The search response.
      */
-    searchAsync(searchRequest: SearchRequest): Promise<SearchResponse>;
+    searchAsync(searchRequest: SearchRequest, cancelCallback?: CancelCallback): Promise<SearchResponse>;
     /**
      * Send a {@link AllFacetsRequest}.
      * @param allFacetsRequest - The all facets search request
+     * @param cancelCallback - A {@link CancelCallback} that will be placed in an axios {@link CancelToken} if provided
      * @returns The search response.
      */
-    allFacetsAsync(allFacetsRequest: AllFacetsRequest): Promise<AllFacetValuesResponse>;
+    allFacetsAsync(allFacetsRequest: AllFacetsRequest, cancelCallback?: CancelCallback): Promise<AllFacetValuesResponse>;
 }
 export declare class SearchClient implements ISearchClient {
     private readonly _client;
     constructor(client: IExtendedContentHubClient);
-    searchAsync(searchRequest: SearchRequest): Promise<SearchResponse>;
-    allFacetsAsync(allFacetsRequest: AllFacetsRequest): Promise<AllFacetValuesResponse>;
+    searchAsync(searchRequest: SearchRequest, cancelCallback?: CancelCallback): Promise<SearchResponse>;
+    allFacetsAsync(allFacetsRequest: AllFacetsRequest, cancelCallback?: CancelCallback): Promise<AllFacetValuesResponse>;
 }

package/dist/clients/search-client.js

@@ -23,21 +23,21 @@ class SearchClient {
         guard_1.default.notNullOrUndefined(client);
         this._client = client;
     }
-    searchAsync(searchRequest) {
+    searchAsync(searchRequest, cancelCallback) {
         return __awaiter(this, void 0, void 0, function* () {
             guard_1.default.notNullOrUndefined(searchRequest);
             const searchLink = yield this._client.linkHelper.searchLinkAsync();
-            const response = yield this._client.raw.postAsync(searchLink.href, ta_json_1.TaJson.serialize(searchRequest));
+            const response = yield this._client.raw.postAsync(searchLink.href, ta_json_1.TaJson.serialize(searchRequest), undefined, cancelCallback);
             response_handler_1.ResponseHandler.handleErrors(response);
             const searchResponse = ta_json_1.TaJson.deserialize(response.content, search_response_1.SearchResponse);
             return searchResponse;
         });
     }
-    allFacetsAsync(allFacetsRequest) {
+    allFacetsAsync(allFacetsRequest, cancelCallback) {
         return __awaiter(this, void 0, void 0, function* () {
             guard_1.default.notNullOrUndefined(allFacetsRequest);
             const allFacetsLink = yield this._client.linkHelper.allFacetsAsync();
-            const response = yield this._client.raw.postAsync(allFacetsLink.href, ta_json_1.TaJson.serialize(allFacetsRequest));
+            const response = yield this._client.raw.postAsync(allFacetsLink.href, ta_json_1.TaJson.serialize(allFacetsRequest), undefined, cancelCallback);
             response_handler_1.ResponseHandler.handleErrors(response);
             const allFacetsResponse = ta_json_1.TaJson.deserialize(response.content, all_facet_values_response_1.AllFacetValuesResponse);
             return allFacetsResponse;
@@ -45,3 +45,4 @@ class SearchClient {
     }
 }
 exports.SearchClient = SearchClient;
+//# sourceMappingURL=search-client.js.map

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

@@ -2,6 +2,7 @@ import { Nullable, NullableResultPromise } from "../base-types";
 import { IEntity } from "../contracts/base/entity";
 import { IEntityLoadConfiguration } from "../contracts/querying/entity-load-configuration";
 import { IExtendedContentHubClient } from "./extended-client";
+import SettingResource from "../models/setting-resource";
 /**
  * Client for fetching setting and category entities.
  */
@@ -20,6 +21,12 @@ export interface ISettingsClient {
      * @returns The setting with the specified name from the specified category or null if that setting doesn't exist.
      */
     getSettingAsync(category: string, name: string, loadConfiguration?: Nullable<IEntityLoadConfiguration>): NullableResultPromise<IEntity>;
+    /**
+     * Gets the setting value and schema for the desired setting name in the specified category.
+     * @param category - The category to get the setting from
+     * @param name - The name of the setting to get
+     */
+    getSettingValueAndSchemaAsync(category: string, name: string): NullableResultPromise<SettingResource>;
     /**
      * Gets the settings for the specified category.
      * @param category - The category to get the setting for
@@ -33,5 +40,6 @@ export declare class SettingsClient implements ISettingsClient {
     constructor(client: IExtendedContentHubClient);
     getCategoryIdAsync(name: string): NullableResultPromise<number>;
     getSettingAsync(category: string, name: string, loadConfiguration?: Nullable<IEntityLoadConfiguration>): NullableResultPromise<IEntity>;
+    getSettingValueAndSchemaAsync(category: string, name: string): NullableResultPromise<SettingResource>;
     getSettingsForCategoryAsync(category: string, loadConfiguration?: Nullable<IEntityLoadConfiguration>): Promise<Array<IEntity>>;
 }

package/dist/clients/settings-client.js

@@ -18,6 +18,7 @@ const filters_1 = require("../contracts/querying/filters");
 const query_1 = require("../contracts/querying/query");
 const invalid_operation_error_1 = require("../errors/invalid-operation-error");
 const guard_1 = __importDefault(require("../guard"));
+const response_handler_1 = require("../clients/response-handler");
 class SettingsClient {
     constructor(client) {
         guard_1.default.notNull(client);
@@ -94,6 +95,17 @@ class SettingsClient {
             return (_a = result.items[0]) !== null && _a !== void 0 ? _a : null;
         });
     }
+    getSettingValueAndSchemaAsync(category, name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.stringNotNullOrEmpty(category);
+            guard_1.default.stringNotNullOrEmpty(name);
+            const link = yield this._client.linkHelper.settingByNameLink(category, name);
+            // Get the setting
+            const result = yield this._client.raw.getAsync(link.href);
+            response_handler_1.ResponseHandler.handleErrors(result);
+            return result.content;
+        });
+    }
     getSettingsForCategoryAsync(category, loadConfiguration = null) {
         return __awaiter(this, void 0, void 0, function* () {
             guard_1.default.stringNotNullOrEmpty(category);
@@ -124,3 +136,4 @@ class SettingsClient {
     }
 }
 exports.SettingsClient = SettingsClient;
+//# sourceMappingURL=settings-client.js.map

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

@@ -1,5 +1,6 @@
 import { UploadRequest } from "../models/upload/upload-request";
 import { IExtendedContentHubClient } from "./extended-client";
+import { CancelCallback } from "./internal-client";
 import { ResponseMessage } from "./response-message";
 /**
  * Client for uploading files (packages).
@@ -10,12 +11,14 @@ export interface IUploadClient {
      * @param request - Describes the file upload.
      * @returns The response of the file upload request.
      */
-    uploadAsync(request: UploadRequest): Promise<ResponseMessage>;
+    uploadAsync(request: UploadRequest, cancelCallback?: CancelCallback): Promise<ResponseMessage>;
 }
 export declare class UploadClient implements IUploadClient {
     private client;
     constructor(client: IExtendedContentHubClient);
-    uploadAsync(request: UploadRequest): Promise<ResponseMessage>;
+    uploadAsync(request: UploadRequest, cancelCallback?: CancelCallback): Promise<ResponseMessage>;
     private uploadFileAsync;
     private uploadChunkAsync;
+    private prepareFormDataNode;
+    private prepareFormDataBrowser;
 }