@sitecore/sc-contenthub-webclient-sdk 0.9.7

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

@@ -0,0 +1,35 @@
+import { MailRequestBroadcast } from "../models/notifications/mail-request-broadcast";
+import { MailRequestById } from "../models/notifications/mail-request-by-id";
+import { MailRequestByUsername } from "../models/notifications/mail-request-by-username";
+import { RealtimeRequestBroadcast } from "../models/notifications/realtime-request-broadcast";
+import { RealtimeRequestById } from "../models/notifications/realtime-request-by-id";
+import { RealtimeRequestByUsername } from "../models/notifications/realtime-request-by-username";
+import { IExtendedContentHubClient } from "./extended-client";
+export interface INotificationsClient {
+    /**
+     * Sends a registration confirmation e-mail to the specified users by id.
+     * This action requires the 'SendConfirmationEmail' privilege.
+     * @param usernames - Usernames or ids that will receive the registration confirmation e-mail
+     */
+    sendConfirmationEmailAsync(usernames: Array<string> | Array<number>): Promise<void>;
+    /**
+     * Sends an e-mail to users by user id, username or to all users.
+     * @param mailRequest - must have type MailRequestById | MailRequestByUsername | MailRequestBroadcast
+     */
+    sendEmailNotificationAsync(mailRequest: MailRequestById | MailRequestByUsername | MailRequestBroadcast): Promise<void>;
+    /**
+     * Sends a real-time notification (browser notification) to users by user id, username or to all users.
+     * @param realtimeRequest - must have type RealtimeRequestById | RealtimeRequestByUsername | RealtimeRequestBroadcast
+     */
+    sendRealTimeNotificationAsync(realtimeRequest: RealtimeRequestById | RealtimeRequestByUsername | RealtimeRequestBroadcast): Promise<void>;
+}
+export declare class NotificationsClient implements INotificationsClient {
+    private readonly _client;
+    constructor(client: IExtendedContentHubClient);
+    sendConfirmationEmailAsync(users: Array<string> | Array<number>): Promise<void>;
+    sendEmailNotificationAsync(mailRequest: MailRequestById | MailRequestByUsername | MailRequestBroadcast): Promise<void>;
+    sendRealTimeNotificationAsync(realtimeRequest: RealtimeRequestById | RealtimeRequestByUsername | RealtimeRequestBroadcast): Promise<void>;
+    private sendPrivateEmailNotificationAsync;
+    private sendPrivateRealTimeNotificationAsync;
+    private sendNotificationAsync;
+}

package/dist/clients/notifications-client.js

@@ -0,0 +1,128 @@
+"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.NotificationsClient = void 0;
+const ta_json_1 = require("ta-json");
+const constants_1 = require("../constants");
+const guard_1 = __importDefault(require("../guard"));
+const notification_mapper_1 = require("../mappers/notification-mapper");
+const distribute_notification_resource_1 = require("../models/notifications/distribute-notification-resource");
+const type_guards_1 = require("../type-guards");
+const response_handler_1 = require("./response-handler");
+class NotificationsClient {
+    constructor(client) {
+        guard_1.default.notNullOrUndefined(client);
+        this._client = client;
+    }
+    //! Not necessary for now, can be added later (lots of boilerplate)
+    // public async getMailTemplateAsync(name: string, loadConfiguration: Nullable<IEntityLoadConfiguration> = null)
+    sendConfirmationEmailAsync(users) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let userIds = [];
+            if (type_guards_1.TypeGuards.isStringArray(users)) {
+                userIds = (yield this._client.users.getUserIdsAsync(users));
+            }
+            else {
+                userIds = users;
+            }
+            guard_1.default.validIds(userIds);
+            for (const userId of userIds) {
+                const link = yield this._client.linkHelper.sendConfirmationMailToLinkAsync(userId);
+                const response = yield this._client.raw.postAsync(link.href, ta_json_1.TaJson.serialize(userId));
+                response_handler_1.ResponseHandler.handleErrors(response);
+            }
+        });
+    }
+    sendEmailNotificationAsync(mailRequest) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.notNullOrUndefined(mailRequest);
+            mailRequest.validate();
+            if ("recipients" in mailRequest) {
+                if (type_guards_1.TypeGuards.isStringArray(mailRequest.recipients)) {
+                    // Usernames
+                    const mailUsernames = mailRequest;
+                    const ids = yield this._client.users.getUserIdsAsync(mailUsernames.recipients);
+                    if (ids !== null) {
+                        yield this.sendPrivateEmailNotificationAsync(mailUsernames, ids);
+                    }
+                }
+                else {
+                    // Ids
+                    const mailIds = mailRequest;
+                    yield this.sendPrivateEmailNotificationAsync(mailIds, mailIds.recipients);
+                }
+            }
+            else {
+                // Broadcast
+                yield this.sendPrivateEmailNotificationAsync(mailRequest, null);
+            }
+        });
+    }
+    sendRealTimeNotificationAsync(realtimeRequest) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.notNull(realtimeRequest);
+            realtimeRequest.validate();
+            if ("recipients" in realtimeRequest) {
+                if (type_guards_1.TypeGuards.isStringArray(realtimeRequest.recipients)) {
+                    // Usernames
+                    const realtimeUsers = realtimeRequest;
+                    const ids = yield this._client.users.getUserIdsAsync(realtimeUsers.recipients);
+                    if (ids !== null) {
+                        yield this.sendPrivateRealTimeNotificationAsync(realtimeRequest, ids);
+                    }
+                }
+                else {
+                    // Ids
+                    const realtimeIds = realtimeRequest;
+                    yield this.sendPrivateRealTimeNotificationAsync(realtimeIds, realtimeIds.recipients);
+                }
+            }
+            else {
+                // Broadcast
+                yield this.sendPrivateRealTimeNotificationAsync(realtimeRequest, null);
+            }
+        });
+    }
+    //#region Private functions
+    sendPrivateEmailNotificationAsync(mailRequest, recipients) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.sendNotificationAsync(mailRequest.mailTemplateName, recipients, "EmailNotification", mailRequest.variables);
+        });
+    }
+    sendPrivateRealTimeNotificationAsync(realtimeRequest, recipients) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const parameters = notification_mapper_1.NotificationMapper.mapParameters(realtimeRequest);
+            return this.sendNotificationAsync(constants_1.NOTIFICATIONS.REALTIME.raw, recipients, "RealTimeNotification", parameters);
+        });
+    }
+    sendNotificationAsync(notificationName, recipients, channel, parameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const link = yield this._client.linkHelper.sendNotificationToLinkAsync(notificationName);
+            // Get user links.
+            let userLinks = null;
+            const linkPromises = recipients === null || recipients === void 0 ? void 0 : recipients.map(id => this._client.linkHelper.entityToLinkAsync(id));
+            if (linkPromises != null) {
+                userLinks = yield Promise.all(linkPromises);
+            }
+            // Create the resource.
+            const resource = new distribute_notification_resource_1.DistributeNotificationResource();
+            resource.recipients = userLinks;
+            resource.channels = [channel];
+            resource.parameters = parameters;
+            const response = yield this._client.raw.postAsync(link.href, ta_json_1.TaJson.serialize(resource));
+            response_handler_1.ResponseHandler.handleErrors(response);
+        });
+    }
+}
+exports.NotificationsClient = NotificationsClient;

package/dist/clients/option-list-client.d.ts

@@ -0,0 +1,49 @@
+import { NullableResultPromise } from "../base-types";
+import { IOptionList } from "../contracts/base/option-lists/option-list";
+import OptionListDescriptionResource from "../models/option-lists/option-list-description-resource";
+import { IExtendedContentHubClient } from "./extended-client";
+export interface IOptionListClient {
+    /**
+     * Gets the names of all option lists that exist.
+     */
+    getAllNamesAsync(): Promise<Array<string>>;
+    /**
+     * Gets an array of all options list descriptions.
+     */
+    getAllDescriptionsAsync(): Promise<Array<OptionListDescriptionResource>>;
+    /**
+     * Gets the option list with the specified name.
+     *
+     * @param name - the option list name
+     */
+    getAsync(name: string): NullableResultPromise<IOptionList>;
+    /**
+     * Creates a new option list
+     *
+     * @param optionList - {@link IOptionList} - the option list instance
+     */
+    createAsync(optionList: IOptionList): Promise<void>;
+    /**
+     * Update an existing option list
+     *
+     * @param optionList - {@link IOptionList} - the option list instance
+     */
+    updateAsync(optionList: IOptionList): Promise<void>;
+    /**
+     * Delete an existing option list
+     *
+     * @param name - the name of the option list
+     */
+    deleteAsync(name: string): Promise<void>;
+}
+export declare class OptionListClient implements IOptionListClient {
+    private readonly _client;
+    private readonly _mapper;
+    constructor(client: IExtendedContentHubClient);
+    getAllNamesAsync(): Promise<Array<string>>;
+    getAllDescriptionsAsync(): Promise<Array<OptionListDescriptionResource>>;
+    getAsync(name: string): NullableResultPromise<IOptionList>;
+    createAsync(optionList: IOptionList): Promise<void>;
+    updateAsync(optionList: IOptionList): Promise<void>;
+    deleteAsync(name: string): Promise<void>;
+}

package/dist/clients/option-list-client.js

@@ -0,0 +1,85 @@
+"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.OptionListClient = void 0;
+const ta_json_1 = require("ta-json");
+const guard_1 = __importDefault(require("../guard"));
+const option_list_mapper_1 = require("../mappers/option-list-mapper");
+const option_list_collection_resource_1 = __importDefault(require("../models/option-lists/option-list-collection-resource"));
+const option_list_resource_1 = __importDefault(require("../models/option-lists/option-list-resource"));
+const response_handler_1 = require("./response-handler");
+class OptionListClient {
+    constructor(client) {
+        this._client = client;
+        this._mapper = new option_list_mapper_1.OptionListMapper(client);
+    }
+    getAllNamesAsync() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const link = yield this._client.linkHelper.dataSourcesLinkAsync();
+            const response = yield this._client.raw.getAsync(link.href);
+            const resource = ta_json_1.TaJson.deserialize(response.content, option_list_collection_resource_1.default);
+            const names = resource.items.map(item => item.name);
+            return names;
+        });
+    }
+    getAllDescriptionsAsync() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const link = yield this._client.linkHelper.dataSourcesLinkAsync();
+            const response = yield this._client.raw.getAsync(link.href);
+            const resource = ta_json_1.TaJson.deserialize(response.content, option_list_collection_resource_1.default);
+            return resource.items;
+        });
+    }
+    getAsync(name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.stringNotNullOrEmpty(name);
+            const link = yield this._client.linkHelper.dataSourceToLinkAsync(name);
+            const response = yield this._client.raw.getAsync(link.href);
+            if (response.statusCode === 404) {
+                return null;
+            }
+            response_handler_1.ResponseHandler.handleErrors(response);
+            const resource = ta_json_1.TaJson.deserialize(response.content, option_list_resource_1.default);
+            const optionList = this._mapper.mapOptionListAsync(resource);
+            return optionList;
+        });
+    }
+    createAsync(optionList) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.notNull(optionList, "optionList");
+            const resource = this._mapper.map(optionList);
+            const link = yield this._client.linkHelper.dataSourcesLinkAsync();
+            const response = yield this._client.raw.postAsync(link.href, ta_json_1.TaJson.serialize(resource));
+            response_handler_1.ResponseHandler.handleErrors(response);
+        });
+    }
+    updateAsync(optionList) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.notNull(optionList, "optionList");
+            const resource = this._mapper.map(optionList);
+            const link = yield this._client.linkHelper.dataSourceToLinkAsync(optionList.name);
+            const response = yield this._client.raw.putAsync(link.href, ta_json_1.TaJson.serialize(resource));
+            response_handler_1.ResponseHandler.handleErrors(response);
+        });
+    }
+    deleteAsync(name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.stringNotNullOrEmpty(name);
+            const link = yield this._client.linkHelper.dataSourceToLinkAsync(name);
+            const response = yield this._client.raw.deleteAsync(link.href);
+            response_handler_1.ResponseHandler.handleErrors(response);
+        });
+    }
+}
+exports.OptionListClient = OptionListClient;

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

@@ -0,0 +1,36 @@
+import CultureInfo from "../culture-info";
+import { PageResource } from "../models/pages/page-resource";
+import { IExtendedContentHubClient } from "./extended-client";
+export interface IPagesClient {
+    /**
+     * Get a page resource by identifier.
+     * @param identifier - The identifier of the page
+     * @param culture - A culture to load the page in
+     * @returns A promise resolving to a {@link PageResource}.
+     * @throws An error when the resource can't be found.
+     */
+    getPageByIdentifierAsync(identifier: string, culture: CultureInfo): Promise<PageResource>;
+    /**
+     * Get a page resource by name.
+     * @param name - The name of the page
+     * @param culture - A culture to load the page in
+     * @returns A promise resolving to a {@link PageResource}.
+     * @throws An error when the resource can't be found.
+     */
+    getPageByNameAsync(name: string, culture: CultureInfo): Promise<PageResource>;
+    /**
+     * Get a page resource by id.
+     * @param id - The id of the page
+     * @param culture - A culture to load the page in
+     * @returns A promise resolving to a {@link PageResource}.
+     * @throws An error when the resource can't be found.
+     */
+    getPageByIdAsync(id: number, culture: CultureInfo): Promise<PageResource>;
+}
+export declare class PagesClient implements IPagesClient {
+    private readonly _client;
+    constructor(client: IExtendedContentHubClient);
+    getPageByNameAsync(name: string, culture: CultureInfo): Promise<PageResource>;
+    getPageByIdentifierAsync(identifier: string, culture: CultureInfo): Promise<PageResource>;
+    getPageByIdAsync(id: number, culture: CultureInfo): Promise<PageResource>;
+}

package/dist/clients/pages-client.js

@@ -0,0 +1,52 @@
+"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.PagesClient = void 0;
+const ta_json_1 = require("ta-json");
+const guard_1 = __importDefault(require("../guard"));
+const page_resource_1 = require("../models/pages/page-resource");
+const response_handler_1 = require("./response-handler");
+class PagesClient {
+    constructor(client) {
+        this._client = client;
+    }
+    getPageByNameAsync(name, culture) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.stringNotNullOrEmpty(name);
+            guard_1.default.notNullOrUndefined(culture);
+            return this.getPageByIdentifierAsync(name, culture);
+        });
+    }
+    getPageByIdentifierAsync(identifier, culture) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.stringNotNullOrEmpty(identifier);
+            guard_1.default.notNullOrUndefined(culture);
+            const link = yield this._client.linkHelper.pageResourceToLinkAsync(identifier, culture);
+            const response = yield this._client.raw.getAsync(link.href);
+            response_handler_1.ResponseHandler.handleErrors(response);
+            return ta_json_1.TaJson.deserialize(response.content, page_resource_1.PageResource);
+        });
+    }
+    getPageByIdAsync(id, culture) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.validId(id);
+            guard_1.default.notNullOrUndefined(culture);
+            const link = yield this._client.linkHelper.pageResourceToLinkAsync(id, culture);
+            const response = yield this._client.raw.getAsync(link.href);
+            response_handler_1.ResponseHandler.handleErrors(response);
+            return ta_json_1.TaJson.deserialize(response.content, page_resource_1.PageResource);
+        });
+    }
+}
+exports.PagesClient = PagesClient;

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

@@ -0,0 +1,47 @@
+import { NullableResultPromise } from "../base-types";
+import { IPolicy } from "../contracts/policies/policy";
+import { IUserGroupPolicy } from "../contracts/policies/user-group-policy";
+import { IUserPolicy } from "../contracts/policies/user-policy";
+import { IExtendedContentHubClient } from "./extended-client";
+/**
+ * Contains functionality to get and update policies.
+ */
+export interface IPoliciesClient {
+    /**
+     * Gets the policy from specified user.
+     *
+     * @remarks
+     * The specified user group id must be a strictly positive number.
+     *
+     * @param userGroupId - Id of the user group to get the policy from
+     * @returns The policy or null when it was not found.
+     */
+    getUserGroupPolicyAsync(userGroupId: number): NullableResultPromise<IUserGroupPolicy>;
+    /**
+     * Gets the policy from specified user.
+     *
+     * @remarks
+     * The specified user id must be a strictly positive number.
+     *
+     * @param userId - Id of the user to get the policy from
+     * @returns The policy or null when it was not found.
+     */
+    getUserPolicyAsync(userId: number): NullableResultPromise<IUserPolicy>;
+    /**
+     * Updates the specified policy.
+     *
+     * @remarks
+     * Throws an error when the policy could not be saved because a validation error occurred.
+     *
+     * @param policy - The policy to update
+     */
+    updateAsync(policy: IPolicy): Promise<void>;
+}
+export declare class PoliciesClient implements IPoliciesClient {
+    private readonly _client;
+    constructor(client: IExtendedContentHubClient);
+    getUserGroupPolicyAsync(userGroupId: number): NullableResultPromise<IUserGroupPolicy>;
+    getUserPolicyAsync(userId: number): NullableResultPromise<IUserPolicy>;
+    updateAsync(policy: IPolicy): Promise<void>;
+    private getPolicyResourceAsync;
+}

package/dist/clients/policies-client.js

@@ -0,0 +1,92 @@
+"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 __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.PoliciesClient = void 0;
+const HttpStatus = __importStar(require("http-status-codes"));
+const ta_json_1 = require("ta-json");
+const error_messages_1 = __importDefault(require("../error-messages"));
+const invalid_operation_error_1 = require("../errors/invalid-operation-error");
+const guard_1 = __importDefault(require("../guard"));
+const policy_mapper_1 = require("../mappers/policy-mapper");
+const policy_resource_1 = require("../models/policies/policy-resource");
+const response_handler_1 = require("./response-handler");
+class PoliciesClient {
+    constructor(client) {
+        guard_1.default.notNull(client);
+        this._client = client;
+    }
+    getUserGroupPolicyAsync(userGroupId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.validId(userGroupId);
+            const resource = yield this.getPolicyResourceAsync(userGroupId);
+            const result = yield policy_mapper_1.PolicyMapper.mapToUserGroupPolicyAsync(this._client, resource);
+            return result;
+        });
+    }
+    getUserPolicyAsync(userId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.validId(userId);
+            const resource = yield this.getPolicyResourceAsync(userId);
+            const result = yield policy_mapper_1.PolicyMapper.mapToUserPolicyAsync(this._client, resource);
+            return result;
+        });
+    }
+    updateAsync(policy) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.notNull(policy);
+            const resource = yield policy_mapper_1.PolicyMapper.mapToResourceAsync(this._client, policy);
+            const id = policy.getRelatedId();
+            if (id == null) {
+                throw new invalid_operation_error_1.InvalidOperationError(error_messages_1.default.PoliciesClient.RelatedIdCannotBeNull);
+            }
+            const link = yield this._client.linkHelper.policyToLinkAsync(id);
+            const content = ta_json_1.TaJson.serialize(resource);
+            const response = yield this._client.raw.postAsync(link.href, content);
+            response_handler_1.ResponseHandler.handleErrors(response);
+        });
+    }
+    //#region Private methods
+    getPolicyResourceAsync(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const link = yield this._client.linkHelper.policyToLinkAsync(id);
+            const response = yield this._client.raw.getAsync(link.href);
+            if (response.statusCode === HttpStatus.NOT_FOUND) {
+                return null;
+            }
+            response_handler_1.ResponseHandler.handleErrors(response);
+            const resource = ta_json_1.TaJson.deserialize(response.content, policy_resource_1.PolicyResource);
+            return resource;
+        });
+    }
+}
+exports.PoliciesClient = PoliciesClient;

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

@@ -0,0 +1,34 @@
+import { Nullable, NullableResultPromise } from "../base-types";
+import { IEntity } from "../contracts/base/entity";
+import { IEntityLoadConfiguration } from "../contracts/querying/entity-load-configuration";
+import { IEntityQueryResult } from "../contracts/querying/entity-query-result";
+import { IIdQueryResult } from "../contracts/querying/id-query-result";
+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";
+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>;
+}
+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>;
+    protected resolveLoadConfiguration(query: Query, loadConfiguration?: IEntityLoadConfiguration): Nullable<IQueryLoadConfiguration>;
+}
+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>;
+}
+export {};

package/dist/clients/querying-client.js

@@ -0,0 +1,95 @@
+"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.QueryingClient = void 0;
+const query_load_configuration_1 = require("../contracts/querying/query-load-configuration");
+const error_messages_1 = __importDefault(require("../error-messages"));
+const invalid_operation_error_1 = require("../errors/invalid-operation-error");
+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");
+class QueryingClientBase {
+    constructor(client) {
+        guard_1.default.notNullOrUndefined(client);
+        this._client = client;
+    }
+    singleAsync(query, loadConfiguration) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.notNullOrUndefined(query);
+            const result = yield this.queryAsync(query, loadConfiguration);
+            if (result.items.length === 0) {
+                return null;
+            }
+            else if (result.items.length > 1) {
+                throw new invalid_operation_error_1.InvalidOperationError(error_messages_1.default.QueryingClient.MultipleResults);
+            }
+            return result.items[0];
+        });
+    }
+    singleIdAsync(query) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.notNullOrUndefined(query);
+            const result = yield this.queryIdsAsync(query);
+            if (result.items.length === 0) {
+                return null;
+            }
+            else if (result.items.length > 1) {
+                throw new invalid_operation_error_1.InvalidOperationError(error_messages_1.default.QueryingClient.MultipleResults);
+            }
+            return result.items[0];
+        });
+    }
+    //? deprecated
+    resolveLoadConfiguration(query, loadConfiguration) {
+        let queryLoadConfiguration;
+        if (loadConfiguration != null) {
+            queryLoadConfiguration = load_options_mapper_1.LoadOptionsMapper.toQueryLoadConfiguration(loadConfiguration);
+        }
+        else {
+            queryLoadConfiguration = query_load_configuration_1.QueryLoadConfiguration.Default;
+        }
+        return queryLoadConfiguration;
+    }
+}
+class QueryingClient extends QueryingClientBase {
+    constructor(client) {
+        super(client);
+        guard_1.default.notNullOrUndefined(client);
+        this._extendedClient = client;
+        this._schemaQuerying = new schema_querying_1.SchemaQuerying(client);
+        this._mapper = new querying_mapper_1.QueryingMapper(client);
+    }
+    queryAsync(query, loadConfiguration) {
+        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);
+            loadConfiguration = load_options_mapper_1.LoadOptionsMapper.toEntityLoadConfiguration(queryLoadConfiguration || undefined);
+            const result = yield this._mapper.mapEntityQueryResultAsync(resource, query, loadConfiguration);
+            return result;
+        });
+    }
+    queryIdsAsync(query) {
+        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 result = yield this._mapper.mapEntityIdQueryResultAsync(resource, query);
+            return result;
+        });
+    }
+}
+exports.QueryingClient = QueryingClient;