@sitecore/sc-contenthub-webclient-sdk 0.9.7

package/dist/clients/settings-client.js

@@ -0,0 +1,126 @@
+"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.SettingsClient = void 0;
+const constants_1 = require("../constants");
+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"));
+class SettingsClient {
+    constructor(client) {
+        guard_1.default.notNull(client);
+        this._client = client;
+    }
+    getCategoryIdAsync(name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.stringNotNullOrEmpty(name);
+            // Build query
+            const query = new query_1.Query();
+            query.filter = new filters_1.CompositeQueryFilter({
+                combineMethod: filters_1.CompositeFilterOperator.And,
+                children: [
+                    new filters_1.DefinitionQueryFilter({
+                        name: constants_1.DEFINITIONS["SettingsCategory"].definitionName,
+                        operator: filters_1.ComparisonOperator.Equals,
+                    }),
+                    new filters_1.PropertyQueryFilter({
+                        operator: filters_1.ComparisonOperator.Contains,
+                        dataType: filters_1.FilterDataType.String,
+                        property: constants_1.DEFINITIONS["SettingsCategory"].name,
+                        value: name,
+                    }),
+                ],
+            });
+            // Get the category
+            const result = yield this._client.querying.queryIdsAsync(query);
+            let id = null;
+            if (!result.items || !result.items.length) {
+                return null;
+            }
+            else if (result.items.length === 1) {
+                id = result.items[0];
+                return id;
+            }
+            else {
+                throw new invalid_operation_error_1.InvalidOperationError("Can't have more than one result, must be unique");
+            }
+        });
+    }
+    getSettingAsync(category, name, loadConfiguration = null) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.stringNotNullOrEmpty(category);
+            guard_1.default.stringNotNullOrEmpty(name);
+            // Get the category id
+            const categoryId = yield this.getCategoryIdAsync(category);
+            if (categoryId == null) {
+                return null;
+            }
+            // Build query
+            const query = new query_1.Query();
+            query.filter = new filters_1.CompositeQueryFilter({
+                combineMethod: filters_1.CompositeFilterOperator.And,
+                children: [
+                    new filters_1.DefinitionQueryFilter({
+                        name: constants_1.DEFINITIONS["Setting"].definitionName,
+                        operator: filters_1.ComparisonOperator.Equals,
+                    }),
+                    new filters_1.PropertyQueryFilter({
+                        operator: filters_1.ComparisonOperator.Contains,
+                        dataType: filters_1.FilterDataType.String,
+                        property: constants_1.DEFINITIONS["Setting"].name,
+                        value: name,
+                    }),
+                    new filters_1.RelationQueryFilter({
+                        relation: constants_1.DEFINITIONS["Setting"].settingCategoryToSettings,
+                        parentId: categoryId,
+                    }),
+                ],
+            });
+            // Get the setting
+            const result = yield this._client.querying.queryAsync(query, loadConfiguration);
+            return (_a = result.items[0]) !== null && _a !== void 0 ? _a : null;
+        });
+    }
+    getSettingsForCategoryAsync(category, loadConfiguration = null) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.stringNotNullOrEmpty(category);
+            // Get the category id
+            const categoryId = yield this.getCategoryIdAsync(category);
+            if (categoryId == null) {
+                throw new invalid_operation_error_1.InvalidOperationError("categoryId was not found");
+            }
+            // Build query
+            const query = new query_1.Query();
+            query.filter = new filters_1.CompositeQueryFilter({
+                combineMethod: filters_1.CompositeFilterOperator.And,
+                children: [
+                    new filters_1.DefinitionQueryFilter({
+                        name: constants_1.DEFINITIONS["Setting"].definitionName,
+                        operator: filters_1.ComparisonOperator.Equals,
+                    }),
+                    new filters_1.RelationQueryFilter({
+                        relation: constants_1.DEFINITIONS["Setting"].settingCategoryToSettings,
+                        parentId: categoryId,
+                    }),
+                ],
+            });
+            // Get the settings
+            const result = yield this._client.querying.queryAsync(query, loadConfiguration);
+            return result.items;
+        });
+    }
+}
+exports.SettingsClient = SettingsClient;

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

@@ -0,0 +1,150 @@
+import { MapNumberTo, MapStringTo, NullableResultPromise } from "../base-types";
+import { IEntity } from "../contracts/base/entity";
+import { EntityLoadConfiguration } from "../contracts/querying/entity-load-configuration";
+import { IExtendedContentHubClient } from "./extended-client";
+export interface IUsersClient {
+    /**
+     * Gets the id of the specified user by username.
+     *
+     * @param username - The user name
+     */
+    getUserIdAsync(username: string): NullableResultPromise<number>;
+    /**
+     * Gets the ids of the specified users by username.
+     *
+     * @param usernames - A list of user names
+     * @returns Array of IDs of type MapStringTo<number>.
+     */
+    getUsernamesToIdsMapAsync(usernames: Array<string>): Promise<MapStringTo<number>>;
+    /**
+     * Gets the ids of the specified users by username.
+     * @param usernames - A list of user names
+     * @returns Array of IDs of type Array<number> or null.
+     */
+    getUserIdsAsync(usernames: Array<string>): NullableResultPromise<Array<number>>;
+    /**
+     * Gets the username of the specified user.
+     *
+     * @param id - The id of the user
+     */
+    getUsernameAsync(id: number): NullableResultPromise<string>;
+    /**
+     * Gets the usernames of the specified users.
+     *
+     * @param ids - The ids of the entities to get
+     */
+    getUsernamesAsync(ids: Array<number>): Promise<MapNumberTo<string>>;
+    /**
+     * Gets the specified user entity.
+     *
+     * @param id - The id of the user
+     * @param loadConfiguration - The load configuration
+     */
+    getUserAsync(id: number, loadConfiguration: EntityLoadConfiguration): NullableResultPromise<IEntity>;
+    /**
+     * Gets the specified user entities.
+     *
+     * @param username - Username of the user
+     * @param loadConfiguration - The load configuration
+     */
+    getUserAsync(username: string, loadConfiguration: EntityLoadConfiguration): NullableResultPromise<IEntity>;
+    /**
+     * Gets the specified user entities.
+     *
+     * @param ids - The ids of the users
+     * @param loadConfiguration - The load configuration
+     */
+    getUsersAsync(ids: Array<number>, loadConfiguration: EntityLoadConfiguration): Promise<Array<IEntity>>;
+    /**
+     * Gets the specified user entities.
+     *
+     * @param usernames - A list of user names
+     * @param loadConfiguration - The load configuration
+     */
+    getUsersAsync(usernames: Array<string>, loadConfiguration: EntityLoadConfiguration): NullableResultPromise<Array<IEntity>>;
+    /**
+     * Gets the id of the specified user group by name.
+     *
+     * @param groupName - The groupName name
+     */
+    getUserGroupIdAsync(groupName: string): NullableResultPromise<number>;
+    /**
+     * Gets the ids of the specified user groups by name.
+     *
+     * @param groupNames - A list of group names
+     */
+    getUserGroupIdsAsync(groupNames: Array<string>): Promise<MapStringTo<number>>;
+    /**
+     * Gets the name of the specified user group
+     *
+     * @param number - The id of the user group
+     */
+    getUserGroupNameAsync(id: number): NullableResultPromise<string>;
+    /**
+     * Gets the name of the specified user groups.
+     *
+     * @param ids - The ids of user groups
+     */
+    getUserGroupNamesAsync(ids: Array<number>): Promise<MapNumberTo<string>>;
+    /**
+     * Gets the specified user group entity.
+     *
+     * @param id - Id of the user
+     * @param loadConfiguration - The load configuration
+     */
+    getUserGroupAsync(id: number, loadConfiguration: EntityLoadConfiguration): NullableResultPromise<IEntity>;
+    /**
+     * Gets the specified user group entity.
+     *
+     * @param groupName - Name of the group
+     * @param loadConfiguration - The load configuration
+     */
+    getUserGroupAsync(groupName: string, loadConfiguration: EntityLoadConfiguration): NullableResultPromise<IEntity>;
+    /**
+     * Gets the specified user group entities.
+     *
+     * @param ids - The ids of the user groups
+     * @param loadConfiguration - The load configuration
+     */
+    getUserGroupsAsync(ids: Array<number>, loadConfiguration: EntityLoadConfiguration): NullableResultPromise<Array<IEntity>>;
+    /**
+     * Gets the specified user group entities.
+     *
+     * @param groupNames - The names of the user groups
+     * @param loadConfiguration - The load configuration
+     */
+    getUserGroupsAsync(groupNames: Array<string>, loadConfiguration: EntityLoadConfiguration): NullableResultPromise<Array<IEntity>>;
+    /**
+     * Changes the password of the specified user.
+     *
+     * @param id - The user id to change the password on
+     * @param password - The password to reset
+     */
+    setPasswordAsync(id: number, password: string): Promise<void>;
+    /**
+     * Resets the password of the specified user.
+     * This sends an e-mail to the specified user with a link to choose a new password.
+     *
+     * @param id - Id of the user
+     */
+    resetPasswordAsync(id: number): Promise<void>;
+}
+export declare class UsersClient implements IUsersClient {
+    protected readonly _client: IExtendedContentHubClient;
+    constructor(client: IExtendedContentHubClient);
+    getUserIdAsync(username: string): NullableResultPromise<number>;
+    getUserIdsAsync(usernames: Array<string>): NullableResultPromise<Array<number>>;
+    getUsernamesToIdsMapAsync(usernames: Array<string>): Promise<MapStringTo<number>>;
+    getUsernameAsync(id: number): NullableResultPromise<string>;
+    getUsernamesAsync(ids: Array<number>): Promise<MapNumberTo<string>>;
+    getUserAsync(param: string | number, loadConfiguration: EntityLoadConfiguration): NullableResultPromise<IEntity>;
+    getUsersAsync(param: Array<number> | Array<string>, loadConfiguration: EntityLoadConfiguration): Promise<Array<IEntity>>;
+    getUserGroupIdAsync(groupName: string): NullableResultPromise<number>;
+    getUserGroupIdsAsync(groupNames: Array<string>): Promise<MapStringTo<number>>;
+    getUserGroupNameAsync(id: number): NullableResultPromise<string>;
+    getUserGroupNamesAsync(ids: Array<number>): Promise<MapNumberTo<string>>;
+    getUserGroupAsync(param: string | number, loadConfiguration: EntityLoadConfiguration): NullableResultPromise<IEntity>;
+    getUserGroupsAsync(param: Array<number> | Array<string>, loadConfiguration: EntityLoadConfiguration): NullableResultPromise<Array<IEntity>>;
+    setPasswordAsync(id: number, password: string): Promise<void>;
+    resetPasswordAsync(id: number): Promise<void>;
+}

package/dist/clients/users-client.js

@@ -0,0 +1,317 @@
+"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.UsersClient = void 0;
+const constants_1 = require("../constants");
+const culture_load_option_1 = require("../contracts/querying/culture-load-option");
+const entity_load_configuration_1 = require("../contracts/querying/entity-load-configuration");
+const filters_1 = require("../contracts/querying/filters");
+const property_load_option_1 = require("../contracts/querying/property-load-option");
+const query_1 = require("../contracts/querying/query");
+const relation_load_option_1 = require("../contracts/querying/relation-load-option");
+const guard_1 = __importDefault(require("../guard"));
+const set_password_request_resource_1 = __importDefault(require("../models/set-password-request-resource"));
+const type_guards_1 = require("../type-guards");
+const response_handler_1 = require("./response-handler");
+class UsersClient {
+    constructor(client) {
+        this._client = client;
+    }
+    //#region Get users
+    getUserIdAsync(username) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.stringNotNullOrEmpty(username);
+            const user = yield this.getUserAsync(username, entity_load_configuration_1.EntityLoadConfiguration.Minimal);
+            return user != null ? user.id : null;
+        });
+    }
+    getUserIdsAsync(usernames) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (usernames == null)
+                return null;
+            if (usernames.length === 0)
+                return [];
+            guard_1.default.arrayNoneNullOrEmptyString(usernames);
+            const theQuery = new query_1.Query({
+                filter: new filters_1.CompositeQueryFilter({
+                    combineMethod: filters_1.CompositeFilterOperator.And,
+                    children: [
+                        new filters_1.DefinitionQueryFilter({
+                            name: constants_1.DEFINITIONS["User"].definitionName,
+                            operator: filters_1.ComparisonOperator.Equals,
+                        }),
+                        new filters_1.PropertyQueryFilter({
+                            operator: filters_1.ComparisonOperator.Equals,
+                            dataType: filters_1.FilterDataType.String,
+                            property: constants_1.DEFINITIONS["User"].username,
+                            values: usernames,
+                        }),
+                    ],
+                }),
+            });
+            const result = yield this._client.querying.queryIdsAsync(theQuery);
+            return result.items;
+        });
+    }
+    getUsernamesToIdsMapAsync(usernames) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.arrayNoneNullOrEmptyString(usernames);
+            const loadConfiguration = new entity_load_configuration_1.EntityLoadConfiguration(culture_load_option_1.CultureLoadOption.None, new property_load_option_1.PropertyLoadOption(constants_1.DEFINITIONS["User"].username));
+            const users = yield this.getUsersAsync(usernames, loadConfiguration);
+            const userObject = {};
+            if (users.length) {
+                users.forEach((user) => {
+                    const username = user.getPropertyValue(constants_1.DEFINITIONS["User"].username);
+                    userObject[username] = user.id;
+                });
+            }
+            return userObject;
+        });
+    }
+    getUsernameAsync(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.validId(id);
+            const loadConfiguration = new entity_load_configuration_1.EntityLoadConfiguration(culture_load_option_1.CultureLoadOption.None, new property_load_option_1.PropertyLoadOption(constants_1.DEFINITIONS["User"].username), relation_load_option_1.RelationLoadOption.None);
+            const user = yield this.getUserAsync(id, loadConfiguration);
+            if (user) {
+                const username = user.getPropertyValue(constants_1.DEFINITIONS["User"].username);
+                return username;
+            }
+            else {
+                return null;
+            }
+        });
+    }
+    getUsernamesAsync(ids) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.validIds(ids);
+            const loadConfiguration = new entity_load_configuration_1.EntityLoadConfiguration(culture_load_option_1.CultureLoadOption.None, new property_load_option_1.PropertyLoadOption(constants_1.DEFINITIONS["User"].username), relation_load_option_1.RelationLoadOption.None);
+            const users = yield this.getUsersAsync(ids, loadConfiguration);
+            const usersObject = {};
+            if (users && users.length) {
+                users.forEach((user) => {
+                    const username = user.getPropertyValue(constants_1.DEFINITIONS["User"].username);
+                    usersObject[user.id] = username;
+                });
+            }
+            return usersObject;
+        });
+    }
+    getUserAsync(param, loadConfiguration) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.notNullOrUndefined(param);
+            if (typeof param === "string") {
+                guard_1.default.stringNotNullOrEmpty(param);
+                const theQuery = new query_1.Query({
+                    filter: new filters_1.CompositeQueryFilter({
+                        combineMethod: filters_1.CompositeFilterOperator.And,
+                        children: [
+                            new filters_1.DefinitionQueryFilter({
+                                name: constants_1.DEFINITIONS["User"].definitionName,
+                                operator: filters_1.ComparisonOperator.Equals,
+                            }),
+                            new filters_1.PropertyQueryFilter({
+                                operator: filters_1.ComparisonOperator.Equals,
+                                dataType: filters_1.FilterDataType.String,
+                                property: constants_1.DEFINITIONS["User"].username,
+                                value: param,
+                            }),
+                        ],
+                    }),
+                    take: 1,
+                });
+                const entity = yield this._client.querying.singleAsync(theQuery, loadConfiguration);
+                return entity;
+            }
+            else {
+                const user = yield this._client.entities.getAsync(param, loadConfiguration);
+                return user;
+            }
+        });
+    }
+    getUsersAsync(param, loadConfiguration) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.notNullOrUndefined(param);
+            if (param.length === 0) {
+                return [];
+            }
+            else if (type_guards_1.TypeGuards.isNumberArray(param)) {
+                guard_1.default.validIds(param);
+                const users = yield this._client.entities.getManyAsync(param, loadConfiguration);
+                return users;
+            }
+            else {
+                guard_1.default.arrayNoneNullOrEmptyString(param);
+                const theQuery = new query_1.Query({
+                    filter: new filters_1.CompositeQueryFilter({
+                        combineMethod: filters_1.CompositeFilterOperator.And,
+                        children: [
+                            new filters_1.DefinitionQueryFilter({
+                                name: constants_1.DEFINITIONS["User"].definitionName,
+                                operator: filters_1.ComparisonOperator.Equals,
+                            }),
+                            new filters_1.PropertyQueryFilter({
+                                operator: filters_1.ComparisonOperator.Equals,
+                                dataType: filters_1.FilterDataType.String,
+                                property: constants_1.DEFINITIONS["User"].username,
+                                values: param,
+                            }),
+                        ],
+                    }),
+                });
+                const entities = yield this._client.querying.queryAsync(theQuery, loadConfiguration);
+                return entities.items;
+            }
+        });
+    }
+    //#endregion
+    //#region Get user groups
+    getUserGroupIdAsync(groupName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.stringNotNullOrEmpty(groupName);
+            const group = yield this.getUserGroupAsync(groupName, entity_load_configuration_1.EntityLoadConfiguration.Minimal);
+            return group != null ? group.id : null;
+        });
+    }
+    getUserGroupIdsAsync(groupNames) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.arrayNoneNullOrEmptyString(groupNames);
+            const loadConfig = new entity_load_configuration_1.EntityLoadConfiguration(culture_load_option_1.CultureLoadOption.None, new property_load_option_1.PropertyLoadOption(constants_1.DEFINITIONS["UserGroup"].groupName), relation_load_option_1.RelationLoadOption.None);
+            const userGroups = yield this.getUserGroupsAsync(groupNames, loadConfig);
+            const userGroupObject = {};
+            if (userGroups && userGroups.length) {
+                userGroups.forEach((userGroup) => {
+                    const groupName = userGroup.getPropertyValue(constants_1.DEFINITIONS["UserGroup"].groupName);
+                    userGroupObject[groupName] = userGroup.id;
+                });
+            }
+            return userGroupObject;
+        });
+    }
+    getUserGroupNameAsync(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.validId(id);
+            const loadConfig = new entity_load_configuration_1.EntityLoadConfiguration(culture_load_option_1.CultureLoadOption.None, new property_load_option_1.PropertyLoadOption(constants_1.DEFINITIONS["UserGroup"].groupName), relation_load_option_1.RelationLoadOption.None);
+            const userGroup = yield this.getUserGroupAsync(id, loadConfig);
+            if (!userGroup) {
+                return null;
+            }
+            const groupName = userGroup.getPropertyValue(constants_1.DEFINITIONS["UserGroup"].groupName);
+            return groupName;
+        });
+    }
+    getUserGroupNamesAsync(ids) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.validIds(ids);
+            const loadConfig = new entity_load_configuration_1.EntityLoadConfiguration(culture_load_option_1.CultureLoadOption.None, new property_load_option_1.PropertyLoadOption(constants_1.DEFINITIONS["UserGroup"].groupName), relation_load_option_1.RelationLoadOption.None);
+            const userGroups = yield this.getUserGroupsAsync(ids, loadConfig);
+            const userGroupObject = {};
+            if (userGroups && userGroups.length) {
+                userGroups.forEach((userGroup) => {
+                    const groupName = userGroup.getPropertyValue(constants_1.DEFINITIONS["UserGroup"].groupName);
+                    userGroupObject[userGroup.id] = groupName;
+                });
+            }
+            return userGroupObject;
+        });
+    }
+    getUserGroupAsync(param, loadConfiguration) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.notNullOrUndefined(param);
+            if (typeof param === "string") {
+                guard_1.default.stringNotNullOrEmpty(param);
+                const theQuery = new query_1.Query({
+                    filter: new filters_1.CompositeQueryFilter({
+                        combineMethod: filters_1.CompositeFilterOperator.And,
+                        children: [
+                            new filters_1.DefinitionQueryFilter({
+                                name: constants_1.DEFINITIONS["UserGroup"].definitionName,
+                                operator: filters_1.ComparisonOperator.Equals,
+                            }),
+                            new filters_1.PropertyQueryFilter({
+                                operator: filters_1.ComparisonOperator.Equals,
+                                dataType: filters_1.FilterDataType.String,
+                                property: constants_1.DEFINITIONS["UserGroup"].groupName,
+                                value: param,
+                            }),
+                        ],
+                    }),
+                    take: 1,
+                });
+                const entity = yield this._client.querying.singleAsync(theQuery, loadConfiguration);
+                return entity;
+            }
+            else {
+                guard_1.default.validId(param);
+                const userGroup = this._client.entities.getAsync(param, loadConfiguration);
+                return userGroup;
+            }
+        });
+    }
+    getUserGroupsAsync(param, loadConfiguration) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.notNullOrUndefined(param);
+            if (param.length === 0) {
+                return [];
+            }
+            else if (type_guards_1.TypeGuards.isNumberArray(param)) {
+                guard_1.default.validIds(param);
+                const userGroups = yield this._client.entities.getManyAsync(param, loadConfiguration);
+                return userGroups;
+            }
+            else {
+                guard_1.default.arrayNoneNullOrEmptyString(param);
+                const theQuery = new query_1.Query({
+                    filter: new filters_1.CompositeQueryFilter({
+                        combineMethod: filters_1.CompositeFilterOperator.And,
+                        children: [
+                            new filters_1.DefinitionQueryFilter({
+                                name: constants_1.DEFINITIONS["UserGroup"].definitionName,
+                                operator: filters_1.ComparisonOperator.Equals,
+                            }),
+                            new filters_1.PropertyQueryFilter({
+                                operator: filters_1.ComparisonOperator.Equals,
+                                dataType: filters_1.FilterDataType.String,
+                                property: constants_1.DEFINITIONS["UserGroup"].groupName,
+                                values: param,
+                            }),
+                        ],
+                    }),
+                });
+                const entities = yield this._client.querying.queryAsync(theQuery, loadConfiguration);
+                return entities.items;
+            }
+        });
+    }
+    //#endregion
+    //#region Password management
+    setPasswordAsync(id, password) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.validId(id);
+            const link = yield this._client.linkHelper.setUserPasswordToLinkAsync(id);
+            const content = new set_password_request_resource_1.default(password);
+            const response = yield this._client.raw.postAsync(link.href, content);
+            response_handler_1.ResponseHandler.handleErrors(response);
+        });
+    }
+    resetPasswordAsync(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.validId(id);
+            const link = yield this._client.linkHelper.resetPasswordToLinkAsync(id);
+            const response = yield this._client.raw.postAsync(link.href);
+            response_handler_1.ResponseHandler.handleErrors(response);
+        });
+    }
+}
+exports.UsersClient = UsersClient;

package/dist/clients/web-content-hub-client.d.ts

@@ -0,0 +1,13 @@
+import { Nullable } from "../base-types";
+import { ILinkHelper } from "../link-helper";
+import { IApiClient } from "./api-client";
+import { IContentHubClient } from "./content-hub-client";
+import { IRawClient } from "./raw-client";
+import { ISearchClient } from "./search-client";
+export interface IWebContentHubClient extends IContentHubClient {
+    readonly impersonatedUsername: Nullable<string>;
+    readonly api: IApiClient;
+    readonly raw: IRawClient;
+    readonly linkHelper: ILinkHelper;
+    readonly search: ISearchClient;
+}

package/dist/clients/web-content-hub-client.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });