@stackfactor/client-api 1.1.128 → 1.1.130

package/lib/integrations/{contentGenerator.js → contentGenerator.ts}

@@ -1,20 +1,40 @@
 import { client } from "../axiosClient.js";
 
+interface GenerateContentData {
+  data: string[];
+  contentType: string;
+  integrationId?: string;
+}
+
+interface GenerateContentAsyncData {
+  id: string;
+  data: object;
+  contentType: string;
+  elementType: string;
+  integrationId?: string;
+  comments: string;
+}
+
 /**
  * Generate content
  * @param {Array<String>} data
  * @param {String} contentType
  * @param {String} integrationId
  * @param {String} token
- * @returns {Object}
+ * @returns {Promise<Object>}
  */
-export const generateContent = (data, contentType, integrationId, token) => {
-  return new Promise(function (resolve, reject) {
-    let data_ = {
+export const generateContent = (
+  data: string[],
+  contentType: string,
+  integrationId: string,
+  token: string
+): Promise<object> => {
+  return new Promise((resolve, reject) => {
+    let data_: GenerateContentData = {
       data: data,
       contentType: contentType,
     };
-    if (integrationId) data.integrationId = integrationId;
+    if (integrationId) data_.integrationId = integrationId;
     const request = client.post(`api/v1/contentgenerators/generate`, data_, {
       headers: { authorization: token },
     });
@@ -29,7 +49,7 @@ export const generateContent = (data, contentType, integrationId, token) => {
 };
 
 /**
- * Generate content aync
+ * Generate content async
  * @param {String} id
  * @param {Object} data
  * @param {String} contentType
@@ -37,24 +57,24 @@ export const generateContent = (data, contentType, integrationId, token) => {
  * @param {String} integrationId
  * @param {String} comments
  * @param {String} token
- * @returns {Object}
+ * @returns {Promise<Object>}
  */
 export const generateContentAsync = (
-  id,
-  data,
-  contentType,
-  elementType,
-  integrationId,
-  comments,
-  token
-) => {
-  return new Promise(function (resolve, reject) {
-    let data_ = {
+  id: string,
+  data: object,
+  contentType: string,
+  elementType: string,
+  integrationId: string,
+  comments: string,
+  token: string
+): Promise<object> => {
+  return new Promise((resolve, reject) => {
+    let data_: GenerateContentAsyncData = {
+      id: id,
       data: data,
       comments: comments,
       contentType: contentType,
       elementType: elementType,
-      id: id,
     };
     if (integrationId) data_.integrationId = integrationId;
     const request = client.post(

package/lib/{learningContent.js → learningContent.ts}

@@ -1,14 +1,35 @@
 import { client } from "./axiosClient.js";
 
+interface LearningContentData {
+  data?: object;
+  id?: string;
+  comments?: string;
+  learningcontentid?: string;
+  microSkillId?: string;
+  tags?: object;
+  watch?: boolean;
+}
+
+interface GenerateLearningActivityContentData {
+  learningObjectives: string;
+  learningActivity: object;
+  microSkillId: string;
+  sections: string[];
+  otherLearningActivities?: string[];
+}
+
 /**
  * Create learning content and set information
  * @param {Object} data Learning content data
  * @param {String} token Authorization token
  * @returns {Promise<Object>} The created learning content
  */
-const createLearningContent = (data, token) => {
-  return new Promise(function (resolve, reject) {
-    const requestData = {
+const createLearningContent = (
+  data: object,
+  token: string
+): Promise<object> => {
+  return new Promise((resolve, reject) => {
+    const requestData: LearningContentData = {
       data: data,
     };
     let confirmationRequest = client.put(
@@ -35,15 +56,18 @@ const createLearningContent = (data, token) => {
  * @param {String} token Authorization token
  * @returns {Promise<Object>} The response from the server
  */
-const deleteLearningContent = (id, comments, token) => {
-  const data = {
+const deleteLearningContent = (
+  id: string,
+  comments: string,
+  token: string
+): Promise<object> => {
+  const data: LearningContentData = {
     id: id,
   };
   if (comments) data.comments = comments;
-  return new Promise(function (resolve, reject) {
+  return new Promise((resolve, reject) => {
     const request = client.delete(`api/v1/learningcontent/`, {
       headers: { authorization: token },
-
       data: data,
     });
     request
@@ -62,12 +86,14 @@ const deleteLearningContent = (id, comments, token) => {
  * @param {String} token Authorization token
  * @returns {Promise<Object>} The response from the server
  */
-const discardLearningContentChanges = (id, token) => {
-  return new Promise(function (resolve, reject) {
+const discardLearningContentChanges = (
+  id: string,
+  token: string
+): Promise<object> => {
+  return new Promise((resolve, reject) => {
     const data = {};
     const request = client.get(`api/v1/learningcontent/discard/${id}`, {
       headers: { authorization: token },
-
       data: data,
     });
     request
@@ -91,16 +117,16 @@ const discardLearningContentChanges = (id, token) => {
  * @param {String} token
  */
 const generateLearningActivityContent = (
-  learningObjectives,
-  skillId,
-  microSkillId,
-  learningActivity,
-  otherLearningActivities,
-  sections,
-  token
-) => {
-  return new Promise(function (resolve, reject) {
-    const requestData = {
+  learningObjectives: string,
+  skillId: string,
+  microSkillId: string,
+  learningActivity: object,
+  otherLearningActivities: string[],
+  sections: string[],
+  token: string
+): Promise<object> => {
+  return new Promise((resolve, reject) => {
+    const requestData: GenerateLearningActivityContentData = {
       learningObjectives: learningObjectives,
       learningActivity: learningActivity,
       microSkillId: microSkillId,
@@ -130,10 +156,13 @@ const generateLearningActivityContent = (
  * Generate micro skill test knowledge
  * @param {String} microSkill
  * @param {String} token
- * @returns {Promise}
+ * @returns {Promise<Object>}
  */
-const generateMicroSkillTestKnowledge = (microSkill, token) => {
-  return new Promise(function (resolve, reject) {
+const generateMicroSkillTestKnowledge = (
+  microSkill: string,
+  token: string
+): Promise<object> => {
+  return new Promise((resolve, reject) => {
     let data = {
       microSkill: microSkill,
     };
@@ -161,8 +190,12 @@ const generateMicroSkillTestKnowledge = (microSkill, token) => {
  * @param {String} token Authorization token
  * @returns {Promise<Object>} The response from the server
  */
-const getLearningContentInformationById = (id, version, token) => {
-  return new Promise(function (resolve, reject) {
+const getLearningContentInformationById = (
+  id: string,
+  version: string,
+  token: string
+): Promise<object> => {
+  return new Promise((resolve, reject) => {
     let confirmationRequest = client.get(
       `api/v1/learningcontent/${id}/${version}`,
       {
@@ -187,9 +220,14 @@ const getLearningContentInformationById = (id, version, token) => {
  * @param {String} token Authorization token
  * @returns {Promise<Array<Object>>} The list of available content
  */
-const getLearningContentList = (filter, version, includeDeleted, token) => {
-  return new Promise(function (resolve, reject) {
-    const requestData = {
+const getLearningContentList = (
+  filter: string[],
+  version: string,
+  includeDeleted: boolean,
+  token: string
+): Promise<object[]> => {
+  return new Promise((resolve, reject) => {
+    const requestData: { version: string; includeDeleted: boolean; filter?: string[] } = {
       version: version,
       includeDeleted: includeDeleted,
     };
@@ -217,8 +255,11 @@ const getLearningContentList = (filter, version, includeDeleted, token) => {
  * @param {String} token Authorization token
  * @returns {Promise<Object>} The response from the server
  */
-const migrateLearningContentStorageType = (id, token) => {
-  return new Promise(function (resolve, reject) {
+const migrateLearningContentStorageType = (
+  id: string,
+  token: string
+): Promise<object> => {
+  return new Promise((resolve, reject) => {
     let data = {};
     let confirmationRequest = client.post(
       `api/v1/learningcontent/migratestorage/${id}`,
@@ -244,9 +285,13 @@ const migrateLearningContentStorageType = (id, token) => {
  * @param {String} token Authorization token
  * @returns {Promise<Object>} The response from the server
  */
-const publishLearningContent = (id, comments, token) => {
-  return new Promise(function (resolve, reject) {
-    let data = {};
+const publishLearningContent = (
+  id: string,
+  comments: string,
+  token: string
+): Promise<object> => {
+  return new Promise((resolve, reject) => {
+    let data: LearningContentData = {};
     if (comments) data.comments = comments;
 
     let confirmationRequest = client.post(
@@ -273,9 +318,13 @@ const publishLearningContent = (id, comments, token) => {
  * @param {String} token Authorization token
  * @returns {Promise<Object>} The updated learning content
  */
-const setLearningContentInformation = (id, data, token) => {
-  return new Promise(function (resolve, reject) {
-    const requestData = {
+const setLearningContentInformation = (
+  id: string,
+  data: object,
+  token: string
+): Promise<object> => {
+  return new Promise((resolve, reject) => {
+    const requestData: LearningContentData = {
       data: data,
       id: id,
     };
@@ -298,14 +347,18 @@ const setLearningContentInformation = (id, data, token) => {
 
 /**
  * Set partial content information
- * @param {*} id
- * @param {*} data
- * @param {*} token
- * @returns
+ * @param {String} id
+ * @param {Object} data
+ * @param {String} token
+ * @returns {Promise<Object>}
  */
-const setLearningContentPartialContentInformation = (id, data, token) => {
-  return new Promise(function (resolve, reject) {
-    const requestData = {
+const setLearningContentPartialContentInformation = (
+  id: string,
+  data: object,
+  token: string
+): Promise<object> => {
+  return new Promise((resolve, reject) => {
+    const requestData: LearningContentData = {
       data: data,
       id: id,
     };
@@ -333,17 +386,17 @@ const setLearningContentPartialContentInformation = (id, data, token) => {
  * @param {String} microSkillId
  * @param {Object} data
  * @param {String} token
- * @returns {Promise<String>} OK word if the operation was succesful
+ * @returns {Promise<String>} OK word if the operation was successful
  */
 const setLearningContentLearningContentInformation = (
-  id,
-  learningcontentid,
-  microSkillId,
-  data,
-  token
-) => {
-  return new Promise(function (resolve, reject) {
-    const requestData = {
+  id: string,
+  learningcontentid: string,
+  microSkillId: string,
+  data: object,
+  token: string
+): Promise<string> => {
+  return new Promise((resolve, reject) => {
+    const requestData: LearningContentData = {
       data: data,
       id: id,
       learningcontentid: learningcontentid,
@@ -372,16 +425,16 @@ const setLearningContentLearningContentInformation = (
  * @param {String} microskillid
  * @param {Object} data
  * @param {String} token
- * @returns {Promise<String>} OK word if the operation was succesful
+ * @returns {Promise<String>} OK word if the operation was successful
  */
 const setLearningContentLearningMicroSkillContentInformation = (
-  id,
-  microskillid,
-  data,
-  token
-) => {
-  return new Promise(function (resolve, reject) {
-    const requestData = {
+  id: string,
+  microskillid: string,
+  data: object,
+  token: string
+): Promise<string> => {
+  return new Promise((resolve, reject) => {
+    const requestData: LearningContentData = {
       data: data,
     };
     let confirmationRequest = client.post(
@@ -407,9 +460,13 @@ const setLearningContentLearningMicroSkillContentInformation = (
  * @param {Object} tags Updated learning content tags
  * @param {String} token Authorization token
  */
-const setLearningContentTags = (id, tags, token) => {
-  return new Promise(function (resolve, reject) {
-    const requestData = {
+const setLearningContentTags = (
+  id: string,
+  tags: object,
+  token: string
+): Promise<object> => {
+  return new Promise((resolve, reject) => {
+    const requestData: LearningContentData = {
       tags: tags,
       id: id,
     };
@@ -436,9 +493,13 @@ const setLearningContentTags = (id, tags, token) => {
  * @param {Boolean} watch Set to true or false
  * @param {String} token Authorization token
  */
-const watchLearningContent = (id, watch, token) => {
-  return new Promise(function (resolve, reject) {
-    const requestData = {
+const watchLearningContent = (
+  id: string,
+  watch: boolean,
+  token: string
+): Promise<object> => {
+  return new Promise((resolve, reject) => {
+    const requestData: LearningContentData = {
       id: id,
       watch: watch,
     };

package/lib/{learningPath.js → learningPath.ts}

@@ -1,12 +1,23 @@
 import { client } from "./axiosClient.js";
 
+interface LearningPathData {
+  data?: object;
+  id?: string;
+  comments?: string;
+  tags?: object;
+  list?: string[];
+  version?: string;
+  includeDeleted?: boolean;
+}
+
 /**
  * Create learning path and set information
  * @param {Object} data
  * @param {String} token Authorization token
+ * @returns {Promise<Object>}
  */
-const createLearningPath = (data, token) => {
-  return new Promise(function (resolve, reject) {
+const createLearningPath = (data: object, token: string): Promise<object> => {
+  return new Promise((resolve, reject) => {
     let confirmationRequest = client.put(
       "api/v1/learningpaths",
       { data: data },
@@ -29,16 +40,16 @@ const createLearningPath = (data, token) => {
  * @param {String} id The id of the template to be deleted
  * @param {String} comments The comments for approver
  * @param {String} token Authorization token
+ * @returns {Promise<Object>}
  */
-const deleteLearningPath = (id, comments, token) => {
-  return new Promise(function (resolve, reject) {
-    const data = {
+const deleteLearningPath = (id: string, comments: string, token: string): Promise<object> => {
+  return new Promise((resolve, reject) => {
+    const data: LearningPathData = {
       id: id,
     };
     if (comments) data.comments = comments;
     const request = client.delete(`api/v1/learningpaths/`, {
       headers: { authorization: token },
-
       data: data,
     });
     request
@@ -55,13 +66,13 @@ const deleteLearningPath = (id, comments, token) => {
  * Discard the training plan draft changes
  * @param {String} id The id of the training plan to be deleted
  * @param {String} token Authorization token
+ * @returns {Promise<Object>}
  */
-const discardLearningPathChanges = (id, token) => {
-  return new Promise(function (resolve, reject) {
+const discardLearningPathChanges = (id: string, token: string): Promise<object> => {
+  return new Promise((resolve, reject) => {
     const data = {};
     const request = client.get(`api/v1/learningpaths/discard/${id}`, {
       headers: { authorization: token },
-
       data: data,
     });
     request
@@ -75,12 +86,14 @@ const discardLearningPathChanges = (id, token) => {
 };
 
 /**
- * Get traing plan template information
+ * Get training plan template information
  * @param {String} id The id of the template
+ * @param {String} version The version of the template
  * @param {String} token Authorization token
+ * @returns {Promise<Object>}
  */
-const getLearningPathInformationById = (id, version, token) => {
-  return new Promise(function (resolve, reject) {
+const getLearningPathInformationById = (id: string, version: string, token: string): Promise<object> => {
+  return new Promise((resolve, reject) => {
     let confirmationRequest = client.get(
       `api/v1/learningpaths/${id}/${version}`,
       {
@@ -101,18 +114,29 @@ const getLearningPathInformationById = (id, version, token) => {
  * Get learning path list
  * @param {Array<String>} list The filter used to select the skill
  * @param {String} version The version to be retrieved
+ * @param {boolean} includeDeleted When true it will return the deleted records as well
  * @param {String} token Authorization token
+ * @returns {Promise<Array<Object>>} The list of available content
  */
-const getLearningPathsList = (list, version, includeDeleted, token) => {
-  return new Promise(function (resolve, reject) {
-    const requestData = {
+const getLearningPathsList = (
+  list: string[],
+  version: string,
+  includeDeleted: boolean,
+  token: string
+): Promise<object[]> => {
+  return new Promise((resolve, reject) => {
+    const requestData: LearningPathData = {
       version: version,
       includeDeleted: includeDeleted,
     };
     if (list) requestData.list = list;
-    let confirmationRequest = client.post(`api/v1/learningpaths`, requestData, {
-      headers: { authorization: token },
-    });
+    let confirmationRequest = client.post(
+      `api/v1/learningpaths`,
+      requestData,
+      {
+        headers: { authorization: token },
+      }
+    );
     confirmationRequest
       .then((response) => {
         resolve(response.data);
@@ -124,14 +148,15 @@ const getLearningPathsList = (list, version, includeDeleted, token) => {
 };
 
 /**
- * Publish training pplan template
+ * Publish training plan template
  * @param {String} id The id of the template to be published
  * @param {String} comments The comments to be include with the request
  * @param {String} token Authorization token
+ * @returns {Promise<Object>}
  */
-const publishLearningPath = (id, comments, token) => {
-  return new Promise(function (resolve, reject) {
-    let data = {};
+const publishLearningPath = (id: string, comments: string, token: string): Promise<object> => {
+  return new Promise((resolve, reject) => {
+    let data: LearningPathData = {};
     if (comments) data.comments = comments;
     let confirmationRequest = client.post(
       `api/v1/learningpaths/publish/${id}`,
@@ -155,10 +180,11 @@ const publishLearningPath = (id, comments, token) => {
  * @param {String} id The id of the template to be updated
  * @param {Object} data Data used to update the template
  * @param {String} token Authorization token
+ * @returns {Promise<Object>}
  */
-const setLearningPathInformation = (id, data, token) => {
-  return new Promise(function (resolve, reject) {
-    const requestData = {
+const setLearningPathInformation = (id: string, data: object, token: string): Promise<object> => {
+  return new Promise((resolve, reject) => {
+    const requestData: LearningPathData = {
       data: data,
       id: id,
     };
@@ -184,10 +210,11 @@ const setLearningPathInformation = (id, data, token) => {
  * @param {String} id The id of the template to be updated
  * @param {Object} tags The updated tags
  * @param {String} token Authorization token
+ * @returns {Promise<Object>}
  */
-const setLearningPathTags = (id, tags, token) => {
-  return new Promise(function (resolve, reject) {
-    const requestData = {
+const setLearningPathTags = (id: string, tags: object, token: string): Promise<object> => {
+  return new Promise((resolve, reject) => {
+    const requestData: LearningPathData = {
       tags: tags,
       id: id,
     };
@@ -217,4 +244,4 @@ export default {
   publishLearningPath,
   setLearningPathInformation,
   setLearningPathTags,
-};
+};

package/lib/{logger.js → logger.ts}

@@ -6,9 +6,15 @@ import { client } from "./axiosClient.js";
  * @param {String} elementType
  * @param {Object} data
  * @param {String} token Authorization token
+ * @returns {Promise<Object>}
  */
-const comments = (elementId, elementType, data, token) => {
-  return new Promise(function (resolve, reject) {
+const comments = (
+  elementId: string,
+  elementType: string,
+  data: object,
+  token: string
+): Promise<object> => {
+  return new Promise((resolve, reject) => {
     let confirmationRequest = client.post(
       "api/v1/logger/comments/",
       {
@@ -36,10 +42,16 @@ const comments = (elementId, elementType, data, token) => {
  * @param {Number} page The results page
  * @param {Number} elementsPerPage The number of elements per page
  * @param {String} token
+ * @returns {Promise<Object>}
  */
-const getListByElementId = (elementId, page, elementsPerPage, token) => {
-  return new Promise(function (resolve, reject) {
-    let data = {};
+const getListByElementId = (
+  elementId: string,
+  page: number | null,
+  elementsPerPage: number | null,
+  token: string
+): Promise<object> => {
+  return new Promise((resolve, reject) => {
+    let data: { elementsPerPage?: number, page?: number } = {};
     if (elementsPerPage !== null) data.elementsPerPage = elementsPerPage;
     if (page !== null) data.page = page;
     const getTokensRequest = client.post(`api/v1/logger/${elementId}`, data, {

package/lib/{microSkillsQuizes.js → microSkillsQuizes.ts}

@@ -5,10 +5,14 @@ import { client } from "./axiosClient.js";
  * @param {String} learningContentId
  * @param {String} microSkillId
  * @param {String} token
- * @returns {Promise}
+ * @returns {Promise<Object>}
  */
-const getResponses = (learningContentId, microSkillId, token) => {
-  return new Promise(function (resolve, reject) {
+const getResponses = (
+  learningContentId: string,
+  microSkillId: string,
+  token: string
+): Promise<object> => {
+  return new Promise((resolve, reject) => {
     let confirmationRequest = client.get(
       `api/v1/microskillsresponses/${learningContentId}/${microSkillId}`,
       {
@@ -31,10 +35,15 @@ const getResponses = (learningContentId, microSkillId, token) => {
  * @param {String} microSkillId
  * @param {Array<Object>} responses
  * @param {String} token Authorization token
- * @returns {Promise}
+ * @returns {Promise<Object>}
  */
-const saveResponses = (learningContentId, microSkillId, responses, token) => {
-  return new Promise(function (resolve, reject) {
+const saveResponses = (
+  learningContentId: string,
+  microSkillId: string,
+  responses: object[],
+  token: string
+): Promise<object> => {
+  return new Promise((resolve, reject) => {
     let data = {
       responses: responses,
     };

package/lib/{quotas.js → quotas.ts}

@@ -3,10 +3,10 @@ import { client } from "./axiosClient.js";
 /**
  * Get the current quota for the user and tenant
  * @param {String} token
- * @returns {Promise}
+ * @returns {Promise<Object>}
  */
-const getAllQuota = (token) => {
-  return new Promise(function (resolve, reject) {
+const getAllQuota = (token: string): Promise<object> => {
+  return new Promise((resolve, reject) => {
     let confirmationRequest = client.get(`/api/v1/quotas/getallquota`, {
       headers: { authorization: token },
     });
@@ -25,9 +25,14 @@ const getAllQuota = (token) => {
  * @param {String} quotaId
  * @param {Number} value
  * @param {String} token
+ * @returns {Promise<Object>}
  */
-const increaseQuotaUtilization = (quotaId, value, token) => {
-  return new Promise(function (resolve, reject) {
+const increaseQuotaUtilization = (
+  quotaId: string,
+  value: number,
+  token: string
+): Promise<object> => {
+  return new Promise((resolve, reject) => {
     let confirmationRequest = client.post(
       `/api/v1/quotas/increaseutilization`,
       {