c8y-nitro 0.1.0 → 0.1.1

package/dist/node_modules/.pnpm/@c8y_client@1023.17.8_encoding@0.1.13/node_modules/@c8y/client/lib/src/user-group/UserGroupService.d.mts

@@ -0,0 +1,215 @@
+import { IIdentified } from "../core/IIdentified.mjs";
+import { IResultList } from "../core/IResultList.mjs";
+import { IResult } from "../core/IResult.mjs";
+import { Service } from "../core/Service.mjs";
+import { ISource } from "../core/ISource.mjs";
+import { IRoleReference } from "../user-role/IRoleReference.mjs";
+import { IUserGroup } from "./IUserGroup.mjs";
+import { IUserReference } from "../user/IUser.mjs";
+
+//#region node_modules/.pnpm/@c8y+client@1023.17.8_encoding@0.1.13/node_modules/@c8y/client/lib/src/user-group/UserGroupService.d.ts
+/**
+ * @description
+ * This service allows for managing user groups.
+ */
+declare class UserGroupService extends Service<IUserGroup> {
+  protected baseUrl: string;
+  protected propertyName: string;
+  protected get listUrl(): string;
+  /**
+   * Gets the details of given user group.
+   *
+   * @param {string|number|IUserGroup} entityOrId Group's id or role object.
+   *
+   * @returns Returns promise object that is resolved with the IUserGroup wrapped by IResult.
+   *
+   * **Example**
+   * ```typescript
+   *
+   *    const groupId: number = 1;
+   *
+   *    (async () => {
+   *      const {data, res} = await userGroupService.detail(roleId);
+   *   })();
+   * ```
+   */
+  detail(entityOrId: string | number | IUserGroup): Promise<IResult<IUserGroup>>;
+  /**
+   * Creates a new user group.
+   *
+   * @param {IUserGroup} entity User Group object.
+   *
+   * @returns {IResult<IUserGroup>} Returns promise object that is resolved with
+   * the details of newly created user group.
+   *
+   * **Example**
+   * ```typescript
+   *
+   *  const userGroupObject: IUserGroup = {
+   *    name: "new user group"
+   *  };
+   *
+   *  (async () => {
+   *    const {data, res} = await userGroupService.create(userGroupObject);
+   *  })();
+   * ```
+   */
+  create(entity: Partial<IUserGroup>): Promise<IResult<IUserGroup>>;
+  /**
+   * Updates user group data.
+   *
+   * @param {Partial<IUserGroup>} entity User group is partially updatable.
+   *
+   * @returns {IResult<IUserGroup>} Returns promise object that is resolved with the saved user group object.
+   *
+   * **Example**
+   * ```typescript
+   *
+   *  const partialUpdateObject: Partial<IUserGroup> = {
+   *     "id" : 1,
+   *     "self" : "[URL to this resource]",
+   *     "name" : "PlatformAdministrators",
+   *     ...
+   *   }
+   *
+   *  (async () => {
+   *    const {data, res} = await userGroupService.update(partialUpdateObject);
+   *  })();
+   * ```
+   */
+  update(entity: Partial<IUserGroup>): Promise<IResult<IUserGroup>>;
+  /**
+   * Gets the list of user groups filtered by parameters.
+   *
+   * @param {object} filter Object containing filters for querying User Groups.
+   *
+   * @returns Returns promise object that is resolved with the IUserGroup wrapped by IResultList.
+   *
+   * **Example**
+   * ```typescript
+   *
+   *  const filter: object = {
+   *     severity: Severity.MAJOR,
+   *     pageSize: 100,
+   *     withTotalPages: true
+   *   };
+   *
+   *   (async () => {
+   *     const {data, res, paging} = await userGroupService.list(filter);
+   *   })();
+   * ```
+   */
+  list(filter?: object): Promise<IResultList<IUserGroup>>;
+  /**
+   * Removes user group.
+   *
+   * @param {number | IIdentified} entityOrId User group's id or user group object.
+   *
+   * @returns Returns promise object that is resolved with the IResult of null.
+   *
+   * **Example**
+   * ```typescript
+   *
+   *    const userGroupId: number = 1;
+   *
+   *    (async () => {
+   *      const {data, res} = await userGroupService.delete(userGroupId);
+   *   })();
+   * ```
+   * When group is removed, suitable audit records are created with type 'User'
+   * and activity 'User updated' with information that user has been removed from group.
+   *
+   * Please, note that the ADMINS and DEVICES groups can not be deleted.
+   */
+  delete(entityOrId: number | IIdentified): Promise<IResult<null>>;
+  /**
+   * Assign role to user group.
+   *
+   * @param {string | number | Partial<IUserGroup>} entityOrId User group's id or user group object.
+   * @param {string | Partial<ISource>} childEntityOrSelf Url to role resource or IRoleReference object.
+   *
+   * @returns Returns promise object that is resolved with the IRoleReference wrapped by IResult.
+   *
+   * **Example**
+   * ```typescript
+   *
+   *    const userGroupId: number = 1;
+   *    const roleResource: string = "[URL to the Role resource]";
+   *
+   *    (async () => {
+   *      const {data, res} = await userGroupService.addRoleToGroup(userGroupId, roleResource);
+   *   })();
+   * ```
+   * When role is assigned to user, suitable audit record is created with type 'User' and activity 'User updated'.
+   */
+  addRoleToGroup(entityOrId: string | number | Partial<IUserGroup>, childEntityOrSelf: string | Partial<ISource>): Promise<IResult<IRoleReference>>;
+  /**
+   * Unassign role from user
+   *
+   * @param {string | number | Partial<IUserGroup>} entityOrId User group's id or user group object.
+   * @param {string | Partial<ISource>} childEntityOrSelf Url to user resource or IRoleReference object.
+   *
+   * @returns Returns promise object that is resolved with the IResult of null.
+   *
+   * **Example**
+   * ```typescript
+   *
+   *    const userGroupId: number = 1;
+   *    const userResource: string = "[URL to the Role resource]";
+   *
+   *    (async () => {
+   *      const {data, res} = await userGroupService.removeRoleFromGroup(userGroupId, userResource);
+   *   })();
+   * ```
+   */
+  removeRoleFromGroup(entityOrId: string | number | Partial<IUserGroup>, childEntityOrSelf: string | Partial<ISource>): Promise<IResult<null>>;
+  /**
+   * Assign user to user group.
+   *
+   * @param {string | number | Partial<IUserGroup>} entityOrId User group's id or user group object.
+   * @param {string | Partial<ISource>} childEntityOrSelf Url to user resource or IUserReference object.
+   *
+   * @returns Returns promise object that is resolved with the IUserReference wrapped by IResult.
+   *
+   * **Example**
+   * ```typescript
+   *
+   *    const userGroupId: number = 1;
+   *    const userResource: string = "[URL to the User resource]";
+   *
+   *    (async () => {
+   *      const {data, res} = await userGroupService.addUserToGroup(userGroupId, userResource);
+   *   })();
+   * ```
+   * When user is added to group, suitable audit record is created with type 'User' and activity 'User updated'.
+   */
+  addUserToGroup(entityOrId: string | number | Partial<IUserGroup>, childEntityOrSelf: string | Partial<ISource>): Promise<IResult<IUserReference>>;
+  /**
+   * Remove user from a group
+   *
+   * @param {string | number | Partial<IUserGroup>} entityOrId User group's id or user group object.
+   * @param {string | Partial<ISource>} childEntityOrSelf Url to user resource or IUserReference object.
+   *
+   * @returns Returns promise object that is resolved with the IResult of null.
+   *
+   * **Example**
+   * ```typescript
+   *
+   *    const userGroupId: number = 1;
+   *    const userResource: string = "[URL to the User resource]";
+   *
+   *    (async () => {
+   *      const {data, res} = await userGroupService.removeUserFromGroup(userGroupId, userResource);
+   *   })();
+   * ```
+   * When user is removed from group, suitable audit record is created with type 'User' and activity 'User updated'.
+   */
+  removeUserFromGroup(entityOrId: string | number | Partial<IUserGroup>, childEntityOrSelf: string | Partial<ISource>): Promise<IResult<null>>;
+  protected getSelf(childReference: string | Partial<ISource>): string;
+  private getChildUrl;
+  private getChildReferenceAsBody;
+  private addChild;
+  private removeChild;
+}
+//#endregion
+export { UserGroupService };

package/dist/node_modules/.pnpm/@c8y_client@1023.17.8_encoding@0.1.13/node_modules/@c8y/client/lib/src/user-role/IRole.d.mts

@@ -0,0 +1,12 @@
+//#region node_modules/.pnpm/@c8y+client@1023.17.8_encoding@0.1.13/node_modules/@c8y/client/lib/src/user-role/IRole.d.ts
+/** Description of IRole interface */
+interface IRole {
+  /** Uniquely identifies a Role */
+  id?: string;
+  /** Descriptive Name of the Role */
+  name?: string;
+  /** Link to this Resource - optional property */
+  self?: string;
+}
+//#endregion
+export { IRole };

package/dist/node_modules/.pnpm/@c8y_client@1023.17.8_encoding@0.1.13/node_modules/@c8y/client/lib/src/user-role/IRoleReference.d.mts

@@ -0,0 +1,19 @@
+import { IRole } from "./IRole.mjs";
+
+//#region node_modules/.pnpm/@c8y+client@1023.17.8_encoding@0.1.13/node_modules/@c8y/client/lib/src/user-role/IRoleReference.d.ts
+/** Description of IRoleReferences interface */
+interface IRoleReferences {
+  /** List of role references */
+  references: IRoleReference[];
+  /** Link to this Resource */
+  self: string;
+}
+/** Description of IRoleReference interface */
+interface IRoleReference {
+  /** A role resource being referenced */
+  role: IRole;
+  /** Link to this Resource */
+  self: string;
+}
+//#endregion
+export { IRoleReference, IRoleReferences };

package/dist/node_modules/.pnpm/@c8y_client@1023.17.8_encoding@0.1.13/node_modules/@c8y/client/lib/src/user-role/UserRoleService.d.mts

@@ -0,0 +1,57 @@
+import { IResultList } from "../core/IResultList.mjs";
+import { IResult } from "../core/IResult.mjs";
+import { Service } from "../core/Service.mjs";
+import { IRole } from "./IRole.mjs";
+
+//#region node_modules/.pnpm/@c8y+client@1023.17.8_encoding@0.1.13/node_modules/@c8y/client/lib/src/user-role/UserRoleService.d.ts
+/**
+ * @description
+ * This service allows for fetch user roles.
+ */
+declare class UserRoleService extends Service<IRole> {
+  protected baseUrl: string;
+  protected listUrl: string;
+  protected propertyName: string;
+  /**
+   * Gets the details of given role.
+   *
+   * @param {string|number|IRole} entityOrId Roles's id or role object.
+   *
+   * @returns Returns promise object that is resolved with the IRole wrapped by IResult.
+   *
+   * **Example**
+   * ```typescript
+   *
+   *    const roleId: number = 1;
+   *
+   *    (async () => {
+   *      const {data, res} = await userRoleService.detail(roleId);
+   *   })();
+   * ```
+   */
+  detail(entityOrId: string | number | IRole): Promise<IResult<IRole>>;
+  /**
+   * Gets the list of user roles filtered by parameters.
+   *
+   * @param {object} filter Object containing filters for querying roles.
+   *
+   * @returns Returns promise object that is resolved with the IRole wrapped by IResultList.
+   *
+   * **Example**
+   * ```typescript
+   *
+   *  const filter: object = {
+   *     severity: Severity.MAJOR,
+   *     pageSize: 100,
+   *     withTotalPages: true
+   *   };
+   *
+   *   (async () => {
+   *     const {data, res, paging} = await userRoleService.list(filter);
+   *   })();
+   * ```
+   */
+  list(filter?: object): Promise<IResultList<IRole>>;
+}
+//#endregion
+export { UserRoleService };

package/dist/node_modules/.pnpm/asynckit@0.4.0/node_modules/asynckit/index.mjs

@@ -0,0 +1,18 @@
+import { __commonJSMin } from "../../../../../_virtual/rolldown_runtime.mjs";
+import { require_parallel } from "./parallel.mjs";
+import { require_serialOrdered } from "./serialOrdered.mjs";
+import { require_serial } from "./serial.mjs";
+
+//#region node_modules/.pnpm/asynckit@0.4.0/node_modules/asynckit/index.js
+var require_asynckit = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = {
+		parallel: require_parallel(),
+		serial: require_serial(),
+		serialOrdered: require_serialOrdered()
+	};
+}));
+
+//#endregion
+export default require_asynckit();
+
+export { require_asynckit };

package/dist/node_modules/.pnpm/asynckit@0.4.0/node_modules/asynckit/lib/abort.mjs

@@ -0,0 +1,29 @@
+import { __commonJSMin } from "../../../../../../_virtual/rolldown_runtime.mjs";
+
+//#region node_modules/.pnpm/asynckit@0.4.0/node_modules/asynckit/lib/abort.js
+var require_abort = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = abort;
+	/**
+	* Aborts leftover active jobs
+	*
+	* @param {object} state - current state object
+	*/
+	function abort(state) {
+		Object.keys(state.jobs).forEach(clean.bind(state));
+		state.jobs = {};
+	}
+	/**
+	* Cleans up leftover job by invoking abort function for the provided job id
+	*
+	* @this  state
+	* @param {string|number} key - job id to abort
+	*/
+	function clean(key) {
+		if (typeof this.jobs[key] == "function") this.jobs[key]();
+	}
+}));
+
+//#endregion
+export default require_abort();
+
+export { require_abort };

package/dist/node_modules/.pnpm/asynckit@0.4.0/node_modules/asynckit/lib/async.mjs

@@ -0,0 +1,32 @@
+import { __commonJSMin } from "../../../../../../_virtual/rolldown_runtime.mjs";
+import { require_defer } from "./defer.mjs";
+
+//#region node_modules/.pnpm/asynckit@0.4.0/node_modules/asynckit/lib/async.js
+var require_async = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var defer = require_defer();
+	module.exports = async;
+	/**
+	* Runs provided callback asynchronously
+	* even if callback itself is not
+	*
+	* @param   {function} callback - callback to invoke
+	* @returns {function} - augmented callback
+	*/
+	function async(callback) {
+		var isAsync = false;
+		defer(function() {
+			isAsync = true;
+		});
+		return function async_callback(err, result) {
+			if (isAsync) callback(err, result);
+			else defer(function nextTick_callback() {
+				callback(err, result);
+			});
+		};
+	}
+}));
+
+//#endregion
+export default require_async();
+
+export { require_async };

package/dist/node_modules/.pnpm/asynckit@0.4.0/node_modules/asynckit/lib/defer.mjs

@@ -0,0 +1,21 @@
+import { __commonJSMin } from "../../../../../../_virtual/rolldown_runtime.mjs";
+
+//#region node_modules/.pnpm/asynckit@0.4.0/node_modules/asynckit/lib/defer.js
+var require_defer = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = defer;
+	/**
+	* Runs provided function on next iteration of the event loop
+	*
+	* @param {function} fn - function to run
+	*/
+	function defer(fn) {
+		var nextTick = typeof setImmediate == "function" ? setImmediate : typeof process == "object" && typeof process.nextTick == "function" ? process.nextTick : null;
+		if (nextTick) nextTick(fn);
+		else setTimeout(fn, 0);
+	}
+}));
+
+//#endregion
+export default require_defer();
+
+export { require_defer };

package/dist/node_modules/.pnpm/asynckit@0.4.0/node_modules/asynckit/lib/iterate.mjs

@@ -0,0 +1,47 @@
+import { __commonJSMin } from "../../../../../../_virtual/rolldown_runtime.mjs";
+import { require_async } from "./async.mjs";
+import { require_abort } from "./abort.mjs";
+
+//#region node_modules/.pnpm/asynckit@0.4.0/node_modules/asynckit/lib/iterate.js
+var require_iterate = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var async = require_async(), abort = require_abort();
+	module.exports = iterate;
+	/**
+	* Iterates over each job object
+	*
+	* @param {array|object} list - array or object (named list) to iterate over
+	* @param {function} iterator - iterator to run
+	* @param {object} state - current job status
+	* @param {function} callback - invoked when all elements processed
+	*/
+	function iterate(list, iterator, state, callback) {
+		var key = state["keyedList"] ? state["keyedList"][state.index] : state.index;
+		state.jobs[key] = runJob(iterator, key, list[key], function(error, output) {
+			if (!(key in state.jobs)) return;
+			delete state.jobs[key];
+			if (error) abort(state);
+			else state.results[key] = output;
+			callback(error, state.results);
+		});
+	}
+	/**
+	* Runs iterator over provided job element
+	*
+	* @param   {function} iterator - iterator to invoke
+	* @param   {string|number} key - key/index of the element in the list of jobs
+	* @param   {mixed} item - job description
+	* @param   {function} callback - invoked after iterator is done with the job
+	* @returns {function|mixed} - job abort function or something else
+	*/
+	function runJob(iterator, key, item, callback) {
+		var aborter;
+		if (iterator.length == 2) aborter = iterator(item, async(callback));
+		else aborter = iterator(item, key, async(callback));
+		return aborter;
+	}
+}));
+
+//#endregion
+export default require_iterate();
+
+export { require_iterate };

package/dist/node_modules/.pnpm/asynckit@0.4.0/node_modules/asynckit/lib/state.mjs

@@ -0,0 +1,33 @@
+import { __commonJSMin } from "../../../../../../_virtual/rolldown_runtime.mjs";
+
+//#region node_modules/.pnpm/asynckit@0.4.0/node_modules/asynckit/lib/state.js
+var require_state = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = state;
+	/**
+	* Creates initial state object
+	* for iteration over list
+	*
+	* @param   {array|object} list - list to iterate over
+	* @param   {function|null} sortMethod - function to use for keys sort,
+	*                                     or `null` to keep them as is
+	* @returns {object} - initial state object
+	*/
+	function state(list, sortMethod) {
+		var isNamedList = !Array.isArray(list), initState = {
+			index: 0,
+			keyedList: isNamedList || sortMethod ? Object.keys(list) : null,
+			jobs: {},
+			results: isNamedList ? {} : [],
+			size: isNamedList ? Object.keys(list).length : list.length
+		};
+		if (sortMethod) initState.keyedList.sort(isNamedList ? sortMethod : function(a, b) {
+			return sortMethod(list[a], list[b]);
+		});
+		return initState;
+	}
+}));
+
+//#endregion
+export default require_state();
+
+export { require_state };

package/dist/node_modules/.pnpm/asynckit@0.4.0/node_modules/asynckit/lib/terminator.mjs

@@ -0,0 +1,26 @@
+import { __commonJSMin } from "../../../../../../_virtual/rolldown_runtime.mjs";
+import { require_async } from "./async.mjs";
+import { require_abort } from "./abort.mjs";
+
+//#region node_modules/.pnpm/asynckit@0.4.0/node_modules/asynckit/lib/terminator.js
+var require_terminator = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var abort = require_abort(), async = require_async();
+	module.exports = terminator;
+	/**
+	* Terminates jobs in the attached state context
+	*
+	* @this  AsyncKitState#
+	* @param {function} callback - final callback to invoke after termination
+	*/
+	function terminator(callback) {
+		if (!Object.keys(this.jobs).length) return;
+		this.index = this.size;
+		abort(this);
+		async(callback)(null, this.results);
+	}
+}));
+
+//#endregion
+export default require_terminator();
+
+export { require_terminator };

package/dist/node_modules/.pnpm/asynckit@0.4.0/node_modules/asynckit/parallel.mjs

@@ -0,0 +1,40 @@
+import { __commonJSMin } from "../../../../../_virtual/rolldown_runtime.mjs";
+import { require_iterate } from "./lib/iterate.mjs";
+import { require_state } from "./lib/state.mjs";
+import { require_terminator } from "./lib/terminator.mjs";
+
+//#region node_modules/.pnpm/asynckit@0.4.0/node_modules/asynckit/parallel.js
+var require_parallel = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var iterate = require_iterate(), initState = require_state(), terminator = require_terminator();
+	module.exports = parallel;
+	/**
+	* Runs iterator over provided array elements in parallel
+	*
+	* @param   {array|object} list - array or object (named list) to iterate over
+	* @param   {function} iterator - iterator to run
+	* @param   {function} callback - invoked when all elements processed
+	* @returns {function} - jobs terminator
+	*/
+	function parallel(list, iterator, callback) {
+		var state = initState(list);
+		while (state.index < (state["keyedList"] || list).length) {
+			iterate(list, iterator, state, function(error, result) {
+				if (error) {
+					callback(error, result);
+					return;
+				}
+				if (Object.keys(state.jobs).length === 0) {
+					callback(null, state.results);
+					return;
+				}
+			});
+			state.index++;
+		}
+		return terminator.bind(state, callback);
+	}
+}));
+
+//#endregion
+export default require_parallel();
+
+export { require_parallel };

package/dist/node_modules/.pnpm/asynckit@0.4.0/node_modules/asynckit/serial.mjs

@@ -0,0 +1,24 @@
+import { __commonJSMin } from "../../../../../_virtual/rolldown_runtime.mjs";
+import { require_serialOrdered } from "./serialOrdered.mjs";
+
+//#region node_modules/.pnpm/asynckit@0.4.0/node_modules/asynckit/serial.js
+var require_serial = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var serialOrdered = require_serialOrdered();
+	module.exports = serial;
+	/**
+	* Runs iterator over provided array elements in series
+	*
+	* @param   {array|object} list - array or object (named list) to iterate over
+	* @param   {function} iterator - iterator to run
+	* @param   {function} callback - invoked when all elements processed
+	* @returns {function} - jobs terminator
+	*/
+	function serial(list, iterator, callback) {
+		return serialOrdered(list, iterator, null, callback);
+	}
+}));
+
+//#endregion
+export default require_serial();
+
+export { require_serial };

package/dist/node_modules/.pnpm/asynckit@0.4.0/node_modules/asynckit/serialOrdered.mjs

@@ -0,0 +1,62 @@
+import { __commonJSMin } from "../../../../../_virtual/rolldown_runtime.mjs";
+import { require_iterate } from "./lib/iterate.mjs";
+import { require_state } from "./lib/state.mjs";
+import { require_terminator } from "./lib/terminator.mjs";
+
+//#region node_modules/.pnpm/asynckit@0.4.0/node_modules/asynckit/serialOrdered.js
+var require_serialOrdered = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var iterate = require_iterate(), initState = require_state(), terminator = require_terminator();
+	module.exports = serialOrdered;
+	module.exports.ascending = ascending;
+	module.exports.descending = descending;
+	/**
+	* Runs iterator over provided sorted array elements in series
+	*
+	* @param   {array|object} list - array or object (named list) to iterate over
+	* @param   {function} iterator - iterator to run
+	* @param   {function} sortMethod - custom sort function
+	* @param   {function} callback - invoked when all elements processed
+	* @returns {function} - jobs terminator
+	*/
+	function serialOrdered(list, iterator, sortMethod, callback) {
+		var state = initState(list, sortMethod);
+		iterate(list, iterator, state, function iteratorHandler(error, result) {
+			if (error) {
+				callback(error, result);
+				return;
+			}
+			state.index++;
+			if (state.index < (state["keyedList"] || list).length) {
+				iterate(list, iterator, state, iteratorHandler);
+				return;
+			}
+			callback(null, state.results);
+		});
+		return terminator.bind(state, callback);
+	}
+	/**
+	* sort helper to sort array elements in ascending order
+	*
+	* @param   {mixed} a - an item to compare
+	* @param   {mixed} b - an item to compare
+	* @returns {number} - comparison result
+	*/
+	function ascending(a, b) {
+		return a < b ? -1 : a > b ? 1 : 0;
+	}
+	/**
+	* sort helper to sort array elements in descending order
+	*
+	* @param   {mixed} a - an item to compare
+	* @param   {mixed} b - an item to compare
+	* @returns {number} - comparison result
+	*/
+	function descending(a, b) {
+		return -1 * ascending(a, b);
+	}
+}));
+
+//#endregion
+export default require_serialOrdered();
+
+export { require_serialOrdered };