@sitecore/sc-contenthub-webclient-sdk 0.9.7

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

@@ -0,0 +1,29 @@
+import URI = require("urijs");
+import { MapStringTo } from "../base-types";
+import { IExtendedContentHubClient } from "./extended-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>>;
+}
+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>>;
+}

package/dist/clients/raw-client.js

@@ -0,0 +1,79 @@
+"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.RawClient = void 0;
+const guard_1 = __importDefault(require("../guard"));
+const http_method_1 = require("../http-method");
+const request_message_1 = require("./request-message");
+class RawClient {
+    constructor(client) {
+        guard_1.default.notNullOrUndefined(client);
+        this._client = client;
+    }
+    getAsync(uri, headers) {
+        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,
+            }));
+        });
+    }
+    postAsync(uri, content, headers) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!headers) {
+                headers = {
+                    "Content-Type": "application/json",
+                };
+            }
+            return yield this._client.internalClient.sendAsync(() => new request_message_1.RequestMessage({
+                requestUri: uri,
+                method: http_method_1.HttpMethod.POST,
+                requestHeaders: headers,
+                content: content,
+            }));
+        });
+    }
+    putAsync(uri, content, headers) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!headers) {
+                headers = {
+                    "Content-Type": "application/json",
+                };
+            }
+            return yield this._client.internalClient.sendAsync(() => new request_message_1.RequestMessage({
+                requestUri: uri,
+                method: http_method_1.HttpMethod.PUT,
+                requestHeaders: headers,
+                content: content,
+            }));
+        });
+    }
+    deleteAsync(uri, headers) {
+        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,
+            }));
+        });
+    }
+    sendAsync(messageFactory) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.notNullOrUndefined(messageFactory);
+            return yield this._client.internalClient.sendAsync(messageFactory);
+        });
+    }
+}
+exports.RawClient = RawClient;

package/dist/clients/request-message.d.ts

@@ -0,0 +1,25 @@
+import URI = require("urijs");
+import { MapStringTo } from "../base-types";
+import { HttpMethod } from "../http-method";
+/**
+ * A request message to be used with {@link IInternalClient} implementations.
+ */
+export declare class RequestMessage<T = any> {
+    /**
+     * HTTP method that indicates the desired action to be performed.
+     */
+    method: HttpMethod;
+    /**
+     * A URI referring to a resource on the Web.
+     */
+    requestUri: URI | string;
+    /**
+     * Headers with additional information that will be sent to the server.
+     */
+    requestHeaders?: MapStringTo<string>;
+    /**
+     * The content (or body) of the message that will be sent to the server.
+     */
+    content?: T;
+    constructor(init?: RequestMessage);
+}

package/dist/clients/request-message.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestMessage = void 0;
+/**
+ * A request message to be used with {@link IInternalClient} implementations.
+ */
+class RequestMessage {
+    constructor(init) {
+        Object.assign(this, init);
+    }
+}
+exports.RequestMessage = RequestMessage;

package/dist/clients/response-handler.d.ts

@@ -0,0 +1,30 @@
+import { ResponseMessage } from "./response-message";
+export declare abstract class ResponseHandler {
+    /**
+     * Inspects the response message's success status.
+     *
+     * @remarks
+     * Throws errors when response message is not successful.
+     *
+     * @param responseMessage - The response message
+     */
+    static handleErrors(responseMessage: ResponseMessage): void;
+    /**
+     * Handle validation errors related to a malformed or in another way invalid request payload send to server.
+     *
+     * @remarks
+     * This method always throws an exception.
+     *
+     * @param responseMessage - The response message
+     */
+    private static handleBadRequest;
+    /**
+     * Handle generic errors.
+     *
+     * @remarks
+     * This method always throws an exception.
+     *
+     * @param responseMessage - The response message
+     */
+    private static handleGenericError;
+}

package/dist/clients/response-handler.js

@@ -0,0 +1,145 @@
+"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 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");
+const validation_error_1 = require("../errors/validation-error");
+const validation_failure_1 = require("../errors/validation-failure");
+const web_api_error_1 = require("../errors/web-api-error");
+const guard_1 = __importDefault(require("../guard"));
+class ResponseHandler {
+    /**
+     * Inspects the response message's success status.
+     *
+     * @remarks
+     * Throws errors when response message is not successful.
+     *
+     * @param responseMessage - The response message
+     */
+    static handleErrors(responseMessage) {
+        guard_1.default.notNullOrUndefined(responseMessage);
+        if (responseMessage.isSuccessStatusCode) {
+            return;
+        }
+        if (responseMessage.statusCode === HttpStatus.BAD_REQUEST) {
+            ResponseHandler.handleBadRequest(responseMessage);
+        }
+        else {
+            ResponseHandler.handleGenericError(responseMessage);
+        }
+    }
+    /**
+     * Handle validation errors related to a malformed or in another way invalid request payload send to server.
+     *
+     * @remarks
+     * This method always throws an exception.
+     *
+     * @param responseMessage - The response message
+     */
+    static handleBadRequest(responseMessage) {
+        guard_1.default.notNullOrUndefined(responseMessage);
+        if (responseMessage.isSuccessStatusCode) {
+            throw new argument_error_1.ArgumentError(`Can not process successful request (code: ${responseMessage.statusCode}).`);
+        }
+        if (responseMessage.statusCode !== HttpStatus.BAD_REQUEST) {
+            throw new argument_error_1.ArgumentError(`Can not process failed request with status code '${responseMessage.statusCode}'.`);
+        }
+        if (responseMessage.content != null) {
+            let json;
+            if (typeof responseMessage.content === "string") {
+                try {
+                    json = JSON.parse(responseMessage.content);
+                }
+                catch (ex) {
+                    throw new validation_error_1.ValidationError(responseMessage.content);
+                }
+            }
+            else {
+                json = responseMessage.content;
+            }
+            throw new validation_error_1.ValidationError("One or more validation errors were detected.", ...Object.keys(json).map(propertyName => new validation_failure_1.ValidationFailure(json[propertyName], propertyName)));
+        }
+        else {
+            throw new validation_error_1.ValidationError("An unspecified error occurred.");
+        }
+    }
+    /**
+     * Handle generic errors.
+     *
+     * @remarks
+     * This method always throws an exception.
+     *
+     * @param responseMessage - The response message
+     */
+    static handleGenericError(responseMessage) {
+        var _a;
+        guard_1.default.notNullOrUndefined(responseMessage);
+        if (responseMessage.isSuccessStatusCode) {
+            throw new argument_error_1.ArgumentError(`Can not process successful request (code: ${responseMessage.statusCode}).`);
+        }
+        let message = null;
+        if (responseMessage.content != null) {
+            let json;
+            try {
+                if (typeof responseMessage.content === "string") {
+                    try {
+                        json = JSON.parse(responseMessage.content);
+                    }
+                    catch (ex) {
+                        throw new validation_error_1.ValidationError(responseMessage.content);
+                    }
+                }
+                else {
+                    json = responseMessage.content;
+                }
+                message = (_a = json["ExceptionMessage"]) !== null && _a !== void 0 ? _a : json["Message"];
+            }
+            catch (ex) { }
+        }
+        message = message !== null && message !== void 0 ? message : responseMessage.content;
+        if (responseMessage.statusCode === HttpStatus.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 (message != null) {
+                message =
+                    `An error has occurred (${responseMessage.statusCode}${responseMessage.statusText != null ? ` - ${responseMessage.statusText}` : ""}).\n` + `Message: ${message}`;
+            }
+            else if (responseMessage.statusCode === HttpStatus.CONFLICT) {
+                message = `Conflict in the parameter value or name (${responseMessage.statusCode}${responseMessage.statusText != null ? ` - ${responseMessage.statusText}` : ""})`;
+            }
+            else {
+                message = `An error has occurred without further information (${responseMessage.statusCode}${responseMessage.statusText != null ? ` - ${responseMessage.statusText}` : ""})`;
+            }
+            throw new web_api_error_1.WebApiError(message, responseMessage.statusCode, responseMessage);
+        }
+    }
+}
+exports.ResponseHandler = ResponseHandler;

package/dist/clients/response-message.d.ts

@@ -0,0 +1,45 @@
+import { CaseInsensitiveStringMap, MapStringTo, OptionalPropertyOf } from "../base-types";
+import { RequestMessage } from "./request-message";
+/**
+ * A response message that will be returned by {@link IInternalClient} instances.
+ */
+export declare class ResponseMessage<T = any> {
+    /**
+     * Headers containing additional information sent by the server.
+     */
+    readonly responseHeaders: CaseInsensitiveStringMap<string>;
+    /**
+     * Status code indicating whether the request was successful or not.
+     */
+    readonly statusCode: number;
+    /**
+     * A textual representation of the current status.
+     */
+    readonly statusText?: string;
+    /**
+     * A reason explaining why the request failed.
+     */
+    readonly reasonPhrase?: string;
+    /**
+     * The request that led to this response.
+     */
+    readonly requestMessage?: RequestMessage;
+    /**
+     * The content (or body) that was returned.
+     */
+    readonly content?: T;
+    /**
+     * Indicates if the response is successful.
+     */
+    get isSuccessStatusCode(): boolean;
+    private constructor();
+    /**
+     * Build a response message.
+     * @param statusCode - HTTP status code
+     * @param responseHeaders - Headers containing additional information sent by the server
+     * @param optional - Object with more response properties (statusText, content, ...)
+     */
+    static build<T>(statusCode: number, responseHeaders?: MapStringTo<string>, optional?: {
+        [key in OptionalPropertyOf<ResponseMessage>]?: any;
+    }): ResponseMessage<T>;
+}

package/dist/clients/response-message.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResponseMessage = void 0;
+const base_types_1 = require("../base-types");
+/**
+ * A response message that will be returned by {@link IInternalClient} instances.
+ */
+class ResponseMessage {
+    constructor(init) {
+        Object.assign(this, init);
+    }
+    /**
+     * Indicates if the response is successful.
+     */
+    get isSuccessStatusCode() {
+        return !!this.statusCode && this.statusCode >= 200 && this.statusCode < 300;
+    }
+    /**
+     * Build a response message.
+     * @param statusCode - HTTP status code
+     * @param responseHeaders - Headers containing additional information sent by the server
+     * @param optional - Object with more response properties (statusText, content, ...)
+     */
+    static build(statusCode, responseHeaders, optional) {
+        var _a;
+        responseHeaders = new base_types_1.CaseInsensitiveStringMap(responseHeaders || {});
+        let reasonPhrase = undefined;
+        if ((statusCode < 200 || statusCode >= 300) && typeof ((_a = optional === null || optional === void 0 ? void 0 : optional.content) === null || _a === void 0 ? void 0 : _a["Message"]) === "string") {
+            reasonPhrase = optional.content["Message"];
+        }
+        return new ResponseMessage(Object.assign(Object.assign({}, optional), { statusCode, responseHeaders, reasonPhrase }));
+    }
+}
+exports.ResponseMessage = ResponseMessage;

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

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

package/dist/clients/schema-querying.js

@@ -0,0 +1,70 @@
+"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.SchemaQuerying = void 0;
+const ta_json_1 = require("ta-json");
+const URITemplate_1 = __importDefault(require("urijs/src/URITemplate"));
+const api_1 = require("../constants/api");
+const query_request_1 = require("../contracts/querying/query-request");
+const guard_1 = __importDefault(require("../guard"));
+const query_result_resource_1 = require("../models/query-result-resource");
+const response_handler_1 = require("./response-handler");
+const URI = require("urijs");
+class SchemaQuerying {
+    constructor(client) {
+        guard_1.default.notNullOrUndefined(client);
+        this._client = client;
+    }
+    queryWithSchemaAsync(query, loadConfiguration) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.notNullOrUndefined(query, "query");
+            guard_1.default.notNullOrUndefined(loadConfiguration, "loadConfiguration");
+            //TODO query.validate();
+            const routes = yield this._client.api.getApiRoutesAsync();
+            const queryEndpoint = routes[api_1.QUERY.templateName];
+            let uri;
+            if (queryEndpoint.templated) {
+                const uriTemplate = new URITemplate_1.default(queryEndpoint.href);
+                uri = uriTemplate.expand({});
+            }
+            else {
+                uri = new URI(queryEndpoint.href);
+            }
+            const queryRequest = new query_request_1.QueryRequest({
+                query: query,
+                loadConfiguration: loadConfiguration,
+            });
+            const resource = yield this.queryEndpointAsync(uri, ta_json_1.TaJson.serialize(queryRequest));
+            return resource;
+        });
+    }
+    scrollWithSchemaAsync(scrollRequest) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error("Method not implemented."); //TODO
+        });
+    }
+    queryEndpointAsync(endpoint, content) {
+        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",
+            });
+            response_handler_1.ResponseHandler.handleErrors(response);
+            const resource = ta_json_1.TaJson.deserialize(response.content, query_result_resource_1.QueryResultResource);
+            return resource;
+        });
+    }
+}
+exports.SchemaQuerying = SchemaQuerying;

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

@@ -0,0 +1,16 @@
+import { SearchRequest } from "../models/search/search-request";
+import { SearchResponse } from "../models/search/search-response";
+import { IExtendedContentHubClient } from "./extended-client";
+export interface ISearchClient {
+    /**
+     * Send a {@link SearchRequest}.
+     * @param searchRequest - The search request
+     * @returns The search response.
+     */
+    searchAsync(searchRequest: SearchRequest): Promise<SearchResponse>;
+}
+export declare class SearchClient implements ISearchClient {
+    private readonly _client;
+    constructor(client: IExtendedContentHubClient);
+    searchAsync(searchRequest: SearchRequest): Promise<SearchResponse>;
+}

package/dist/clients/search-client.js

@@ -0,0 +1,36 @@
+"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.SearchClient = void 0;
+const ta_json_1 = require("ta-json");
+const guard_1 = __importDefault(require("../guard"));
+const search_response_1 = require("../models/search/search-response");
+const response_handler_1 = require("./response-handler");
+class SearchClient {
+    constructor(client) {
+        guard_1.default.notNullOrUndefined(client);
+        this._client = client;
+    }
+    searchAsync(searchRequest) {
+        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));
+            response_handler_1.ResponseHandler.handleErrors(response);
+            const searchResponse = ta_json_1.TaJson.deserialize(response.content, search_response_1.SearchResponse);
+            return searchResponse;
+        });
+    }
+}
+exports.SearchClient = SearchClient;

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

@@ -0,0 +1,37 @@
+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";
+/**
+ * Client for fetching setting and category entities.
+ */
+export interface ISettingsClient {
+    /**
+     * Gets the id of a category by name.
+     * @param name - cannot be an empty or whitespace string
+     * @returns Id of the category entity.
+     */
+    getCategoryIdAsync(name: string): NullableResultPromise<number>;
+    /**
+     * Gets the setting with the specified name from the specified category.
+     * @param category - The category to get the setting from
+     * @param name - The name of the setting to get
+     * @param loadConfiguration - Load configuration
+     * @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 settings for the specified category.
+     * @param category - The category to get the setting for
+     * @param loadConfiguration - Load configuration
+     * @returns A list of all setting entities for the specified category.
+     */
+    getSettingsForCategoryAsync(category: string, loadConfiguration?: Nullable<IEntityLoadConfiguration>): Promise<Array<IEntity>>;
+}
+export declare class SettingsClient implements ISettingsClient {
+    private readonly _client;
+    constructor(client: IExtendedContentHubClient);
+    getCategoryIdAsync(name: string): NullableResultPromise<number>;
+    getSettingAsync(category: string, name: string, loadConfiguration?: Nullable<IEntityLoadConfiguration>): NullableResultPromise<IEntity>;
+    getSettingsForCategoryAsync(category: string, loadConfiguration?: Nullable<IEntityLoadConfiguration>): Promise<Array<IEntity>>;
+}