@selfcommunity/api-services 0.1.6 → 0.1.7

package/lib/esm/services/feed_object/index.js

@@ -3,543 +3,377 @@
 exports.__esModule = true;
 exports.default = exports.FeedObjectApiClient = void 0;
 
-var _client = _interopRequireDefault(require("../../client"));
+var _apiRequest = require("../../utils/apiRequest");
 
 var _Endpoints = _interopRequireDefault(require("../../constants/Endpoints"));
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
+/**
+ * Contains all the endpoints needed to manage feed objs (discussions-posts-statuses).
+ */
 class FeedObjectApiClient {
-  static getAllFeedObjects(type) {
-    return _client.default.request({
-      url: _Endpoints.default.FeedObjectList.url({
-        type
-      }),
-      method: _Endpoints.default.FeedObjectList.method
-    }).then(res => {
-      if (res.status >= 300) {
-        console.log(`Unable to retrieve feed objects (Response code: ${res.status}).`);
-        return Promise.reject(res);
-      }
-
-      return Promise.resolve(res);
-    }).catch(error => {
-      console.log('Unable to retrieve feed objects.');
-      return Promise.reject(error);
-    });
-  }
+  /**
+   * This endpoint retrieves all feed objs
+   * @param type
+   * @param params
+   */
+  static getAllFeedObjects(type, params) {
+    const p = new URLSearchParams(params);
+    return (0, _apiRequest.apiRequest)(`${_Endpoints.default.FeedObjectList.url({
+      type
+    })}?${p.toString()}`, _Endpoints.default.FeedObjectList.method);
+  }
+  /**
+   * This endpoint retrieves all uncommented feed objs
+   * @param type
+   * @param params
+   */
+
+
+  static getUncommentedFeedObjects(type, params) {
+    const p = new URLSearchParams(params);
+    return (0, _apiRequest.apiRequest)(`${_Endpoints.default.FeedObjectsUncommented.url({
+      type
+    })}?${p.toString()}`, _Endpoints.default.FeedObjectsUncommented.method);
+  }
+  /**
+   * This endpoint performs search operation to feed objs
+   * @param type
+   */
 
-  static getUncommentedFeedObjects(type) {
-    return _client.default.request({
-      url: _Endpoints.default.FeedObjectsUncommented.url({
-        type
-      }),
-      method: _Endpoints.default.FeedObjectsUncommented.method
-    }).then(res => {
-      if (res.status >= 300) {
-        console.log(`Unable to retrieve uncommented feed object (Response code: ${res.status}).`);
-        return Promise.reject(res);
-      }
-
-      return Promise.resolve(res);
-    }).catch(error => {
-      console.log('Unable to retrieve uncommented feed object.');
-      return Promise.reject(error);
-    });
-  }
 
   static searchFeedObject(type) {
-    return _client.default.request({
-      url: _Endpoints.default.SearchFeedObject.url({
-        type
-      }),
-      method: _Endpoints.default.SearchFeedObject.method
-    }).then(res => {
-      if (res.status >= 300) {
-        console.log(`Unable to retrieve feed object (Response code: ${res.status}).`);
-        return Promise.reject(res);
-      }
-
-      return Promise.resolve(res);
-    }).catch(error => {
-      console.log('Unable to retrieve feed object.');
-      return Promise.reject(error);
-    });
+    return (0, _apiRequest.apiRequest)(_Endpoints.default.SearchFeedObject.url({
+      type
+    }), _Endpoints.default.SearchFeedObject.method);
   }
+  /**
+   * This endpoint creates a feed obj
+   * @param type
+   * @param data
+   */
 
-  static createFeedObject(type) {
-    return _client.default.request({
-      url: _Endpoints.default.CreateFeedObject.url({
-        type
-      }),
-      method: _Endpoints.default.CreateFeedObject.method
-    }).then(res => {
-      if (res.status >= 300) {
-        console.log(`Unable to perform action (Response code: ${res.status}).`);
-        return Promise.reject(res);
-      }
-
-      return Promise.resolve(res);
-    }).catch(error => {
-      console.log('Unable to perform action.');
-      return Promise.reject(error);
-    });
+
+  static createFeedObject(type, data) {
+    return (0, _apiRequest.apiRequest)(_Endpoints.default.CreateFeedObject.url({
+      type
+    }), _Endpoints.default.CreateFeedObject.method, data);
   }
+  /**
+   * This endpoint retrieves a specific feed obj using ID
+   * @param type
+   * @param id
+   */
+
 
   static getSpecificFeedObject(type, id) {
-    return _client.default.request({
-      url: _Endpoints.default.FeedObject.url({
-        type,
-        id
-      }),
-      method: _Endpoints.default.FeedObject.method
-    }).then(res => {
-      if (res.status >= 300) {
-        console.log(`Unable to retrieve feed object (Response code: ${res.status}).`);
-        return Promise.reject(res);
-      }
-
-      return Promise.resolve(res);
-    }).catch(error => {
-      console.log('Unable to retrieve feed object.');
-      return Promise.reject(error);
-    });
+    return (0, _apiRequest.apiRequest)(_Endpoints.default.FeedObject.url({
+      type,
+      id
+    }), _Endpoints.default.FeedObject.method);
   }
+  /**
+   * This endpoint updates a specific feed obj
+   * @param type
+   * @param id
+   * @param data
+   */
 
-  static updateFeedObject(type, id) {
-    return _client.default.request({
-      url: _Endpoints.default.UpdateFeedObject.url({
-        id,
-        type
-      }),
-      method: _Endpoints.default.UpdateFeedObject.method
-    }).then(res => {
-      if (res.status >= 300) {
-        console.log(`Unable to perform action (Response code: ${res.status}).`);
-        return Promise.reject(res);
-      }
-
-      return Promise.resolve(res);
-    }).catch(error => {
-      console.log('Unable to perform action.');
-      return Promise.reject(error);
-    });
-  }
 
-  static deleteFeedObject(type, id) {
-    return _client.default.request({
-      url: _Endpoints.default.DeleteFeedObject.url({
-        type,
-        id
-      }),
-      method: _Endpoints.default.DeleteFeedObject.method
-    }).then(res => {
-      if (res.status >= 300) {
-        console.log(`Unable to perform action (Response code: ${res.status}).`);
-        return Promise.reject(res);
-      }
-
-      return Promise.resolve(res);
-    }).catch(error => {
-      console.log('Unable to perform action.');
-      return Promise.reject(error);
-    });
+  static updateFeedObject(type, id, data) {
+    return (0, _apiRequest.apiRequest)(_Endpoints.default.UpdateFeedObject.url({
+      id,
+      type
+    }), _Endpoints.default.UpdateFeedObject.method, data);
   }
+  /**
+   * This endpoint deletes a specific feed obj
+   * @param type
+   * @param id
+   */
 
-  static feedObjectContributorsList(type, id) {
-    return _client.default.request({
-      url: _Endpoints.default.FeedObjectContributorsList.url({
-        type,
-        id
-      }),
-      method: _Endpoints.default.FeedObjectContributorsList.method
-    }).then(res => {
-      if (res.status >= 300) {
-        console.log(`Unable to retrieve feed object contributors (Response code: ${res.status}).`);
-        return Promise.reject(res);
-      }
-
-      return Promise.resolve(res);
-    }).catch(error => {
-      console.log('Unable to retrieve feed object contributors.');
-      return Promise.reject(error);
-    });
-  }
 
-  static feedObjectSharesList(type, id) {
-    return _client.default.request({
-      url: _Endpoints.default.FeedObjectSharesList.url({
-        type,
-        id
-      }),
-      method: _Endpoints.default.FeedObjectSharesList.method
-    }).then(res => {
-      if (res.status >= 300) {
-        console.log(`Unable to retrieve feed object shares (Response code: ${res.status}).`);
-        return Promise.reject(res);
-      }
-
-      return Promise.resolve(res);
-    }).catch(error => {
-      console.log('Unable to retrieve feed object shares.');
-      return Promise.reject(error);
-    });
-  }
+  static deleteFeedObject(type, id) {
+    return (0, _apiRequest.apiRequest)(_Endpoints.default.DeleteFeedObject.url({
+      type,
+      id
+    }), _Endpoints.default.DeleteFeedObject.method);
+  }
+  /**
+   * This endpoint retrieves all contributors for a specific feed obj
+   * @param type
+   * @param id
+   * @param params
+   */
+
+
+  static feedObjectContributorsList(type, id, params) {
+    const p = new URLSearchParams(params);
+    return (0, _apiRequest.apiRequest)(`${_Endpoints.default.FeedObjectContributorsList.url({
+      type,
+      id
+    })}?${p.toString()}`, _Endpoints.default.FeedObjectContributorsList.method);
+  }
+  /**
+   * This endpoint retrieves all shares for a specific feed obj
+   * @param type
+   * @param id
+   * @param params
+   */
+
+
+  static feedObjectSharesList(type, id, params) {
+    const p = new URLSearchParams(params);
+    return (0, _apiRequest.apiRequest)(`${_Endpoints.default.FeedObjectSharesList.url({
+      type,
+      id
+    })}?${p.toString()}`, _Endpoints.default.FeedObjectSharesList.method);
+  }
+  /**
+   * This endpoint retrieves all shares users for a specific feed obj
+   * @param type
+   * @param id
+   * @param params
+   */
+
+
+  static feedObjectUserSharesList(type, id, params) {
+    const p = new URLSearchParams(params);
+    return (0, _apiRequest.apiRequest)(`${_Endpoints.default.FeedObjectUserSharesList.url({
+      type,
+      id
+    })}?${p.toString()}`, _Endpoints.default.FeedObjectUserSharesList.method);
+  }
+  /**
+   *
+   * @param type
+   * @param id
+   */
 
-  static feedObjectUserSharesList(type, id) {
-    return _client.default.request({
-      url: _Endpoints.default.FeedObjectUserSharesList.url({
-        type,
-        id
-      }),
-      method: _Endpoints.default.FeedObjectUserSharesList.method
-    }).then(res => {
-      if (res.status >= 300) {
-        console.log(`Unable to retrieve feed object users shares (Response code: ${res.status}).`);
-        return Promise.reject(res);
-      }
-
-      return Promise.resolve(res);
-    }).catch(error => {
-      console.log('Unable to retrieve feed object users shares.');
-      return Promise.reject(error);
-    });
-  }
 
   static restoreFeedObject(type, id) {
-    return _client.default.request({
-      url: _Endpoints.default.RestoreFeedObject.url({
-        type,
-        id
-      }),
-      method: _Endpoints.default.RestoreFeedObject.method
-    }).then(res => {
-      if (res.status >= 300) {
-        console.log(`Unable to perform action (Response code: ${res.status}).`);
-        return Promise.reject(res);
-      }
-
-      return Promise.resolve(res);
-    }).catch(error => {
-      console.log('Unable to perform action.');
-      return Promise.reject(error);
-    });
+    return (0, _apiRequest.apiRequest)(_Endpoints.default.RestoreFeedObject.url({
+      type,
+      id
+    }), _Endpoints.default.RestoreFeedObject.method);
   }
+  /**
+   * This endpoint restores a feed obj
+   * @param type
+   * @param id
+   * @param params
+   */
 
-  static relatedFeedObjects(type, id) {
-    return _client.default.request({
-      url: _Endpoints.default.RelatedFeedObjects.url({
-        type,
-        id
-      }),
-      method: _Endpoints.default.RelatedFeedObjects.method
-    }).then(res => {
-      if (res.status >= 300) {
-        console.log(`Unable to retrieve related feed objects (Response code: ${res.status}).`);
-        return Promise.reject(res);
-      }
-
-      return Promise.resolve(res);
-    }).catch(error => {
-      console.log('Unable to retrieve related feed objects.');
-      return Promise.reject(error);
-    });
+
+  static relatedFeedObjects(type, id, params) {
+    const p = new URLSearchParams(params);
+    return (0, _apiRequest.apiRequest)(`${_Endpoints.default.RelatedFeedObjects.url({
+      type,
+      id
+    })}?${p.toString()}`, _Endpoints.default.RelatedFeedObjects.method);
   }
+  /**
+   * This endpoint upvotes a specific feed obj
+   * @param type
+   * @param id
+   */
+
 
   static voteFeedObject(type, id) {
-    return _client.default.request({
-      url: _Endpoints.default.Vote.url({
-        type,
-        id
-      }),
-      method: _Endpoints.default.Vote.method
-    }).then(res => {
-      if (res.status >= 300) {
-        console.log(`Unable to perform action (Response code: ${res.status}).`);
-        return Promise.reject(res);
-      }
-
-      return Promise.resolve(res);
-    }).catch(error => {
-      console.log('Unable to perform action.');
-      return Promise.reject(error);
+    return (0, _apiRequest.apiRequest)(_Endpoints.default.Vote.url({
+      type,
+      id
+    }), _Endpoints.default.Vote.method);
+  }
+  /**
+   * This endpoint retrieves all votes for a specific feed obj
+   * @param type
+   * @param id
+   * @param params
+   */
+
+
+  static feedObjectVotes(type, id, params) {
+    const p = new URLSearchParams(params);
+    return (0, _apiRequest.apiRequest)(`${_Endpoints.default.VotesList.url({
+      type,
+      id
+    })}?${p.toString()}`, _Endpoints.default.VotesList.method);
+  }
+  /**
+   * This endpoint upvotes a specific poll choice in a feed obj
+   * @param type It can be only "discussion" or "post".
+   * @param id
+   * @param choice
+   */
+
+
+  static feedObjectPollVote(type, id, choice) {
+    return (0, _apiRequest.apiRequest)(_Endpoints.default.PollVote.url({
+      type,
+      id
+    }), _Endpoints.default.PollVote.method, {
+      choice: choice
     });
   }
+  /**
+   * This endpoint retrieves all poll votes for a specific feed obj
+   * @param type It can be only "discussion" or "post".
+   * @param id
+   * @param params
+   */
 
-  static feedObjectVotes(type, id) {
-    return _client.default.request({
-      url: _Endpoints.default.VotesList.url({
-        type,
-        id
-      }),
-      method: _Endpoints.default.VotesList.method
-    }).then(res => {
-      if (res.status >= 300) {
-        console.log(`Unable to retrieve feed object votes (Response code: ${res.status}).`);
-        return Promise.reject(res);
-      }
-
-      return Promise.resolve(res);
-    }).catch(error => {
-      console.log('Unable to retrieve feed object votes.');
-      return Promise.reject(error);
-    });
-  }
 
-  static feedObjectPollVote(type, id) {
-    return _client.default.request({
-      url: _Endpoints.default.PollVote.url({
-        type,
-        id
-      }),
-      method: _Endpoints.default.PollVote.method
-    }).then(res => {
-      if (res.status >= 300) {
-        console.log(`Unable to perform action (Response code: ${res.status}).`);
-        return Promise.reject(res);
-      }
-
-      return Promise.resolve(res);
-    }).catch(error => {
-      console.log('Unable to perform action.');
-      return Promise.reject(error);
-    });
+  static feedObjectPollVotesList(type, id, params) {
+    const p = new URLSearchParams(params);
+    return (0, _apiRequest.apiRequest)(`${_Endpoints.default.PollVotesList.url({
+      type,
+      id
+    })}?${p.toString()}`, _Endpoints.default.PollVotesList.method);
   }
+  /**
+   * This endpoint follows a feed obj
+   * @param type
+   * @param id
+   */
 
-  static feedObjectPollVotesList(type, id) {
-    return _client.default.request({
-      url: _Endpoints.default.PollVotesList.url({
-        type,
-        id
-      }),
-      method: _Endpoints.default.PollVotesList.method
-    }).then(res => {
-      if (res.status >= 300) {
-        console.log(`Unable to retrieve poll votes (Response code: ${res.status}).`);
-        return Promise.reject(res);
-      }
-
-      return Promise.resolve(res);
-    }).catch(error => {
-      console.log('Unable to retrieve poll votes.');
-      return Promise.reject(error);
-    });
-  }
 
   static followFeedObject(type, id) {
-    return _client.default.request({
-      url: _Endpoints.default.FollowContribution.url({
-        id
-      }),
-      method: _Endpoints.default.FollowContribution.method
-    }).then(res => {
-      if (res.status >= 300) {
-        console.log(`Unable to perform follow action (Response code: ${res.status}).`);
-        return Promise.reject(res);
-      }
-
-      return Promise.resolve(res);
-    }).catch(error => {
-      console.log('Unable to perform follow action.');
-      return Promise.reject(error);
-    });
+    return (0, _apiRequest.apiRequest)(_Endpoints.default.FollowContribution.url({
+      id
+    }), _Endpoints.default.FollowContribution.method);
   }
+  /**
+   * This endpoint retrieves all feed objs followed by the authenticated user
+   * @param type
+   * @param params
+   */
 
-  static feedObjectFollowingList(type) {
-    return _client.default.request({
-      url: _Endpoints.default.FeedObjectFollowingList.url({
-        type
-      }),
-      method: _Endpoints.default.FeedObjectFollowingList.method
-    }).then(res => {
-      if (res.status >= 300) {
-        console.log(`Unable to retrieve feed object followings (Response code: ${res.status}).`);
-        return Promise.reject(res);
-      }
-
-      return Promise.resolve(res);
-    }).catch(error => {
-      console.log('Unable to retrieve feed object followings.');
-      return Promise.reject(error);
-    });
+
+  static feedObjectFollowingList(type, params) {
+    const p = new URLSearchParams(params);
+    return (0, _apiRequest.apiRequest)(`${_Endpoints.default.FeedObjectFollowingList.url({
+      type
+    })}?${p.toString()}`, _Endpoints.default.FeedObjectFollowingList.method);
   }
+  /**
+   * This endpoint returns following = true if the feed obj (identified in path) is followed by the authenticated user
+   * @param type
+   * @param id
+   */
+
 
   static checkIfFollowingFeedObject(type, id) {
-    return _client.default.request({
-      url: _Endpoints.default.CheckIfFollowingFeedObject.url({
-        type,
-        id
-      }),
-      method: _Endpoints.default.CheckIfFollowingFeedObject.method
-    }).then(res => {
-      if (res.status >= 300) {
-        console.log(`Unable to perform action (Response code: ${res.status}).`);
-        return Promise.reject(res);
-      }
-
-      return Promise.resolve(res);
-    }).catch(error => {
-      console.log('Unable to perform action.');
-      return Promise.reject(error);
-    });
+    return (0, _apiRequest.apiRequest)(_Endpoints.default.CheckIfFollowingFeedObject.url({
+      type,
+      id
+    }), _Endpoints.default.CheckIfFollowingFeedObject.method);
   }
+  /**
+   * This endpoint suspends the notifications for the selected feed obj
+   * @param type
+   * @param id
+   */
+
 
   static suspendFeedObject(type, id) {
-    return _client.default.request({
-      url: _Endpoints.default.UserSuspendContributionNotification.url({
-        type,
-        id
-      }),
-      method: _Endpoints.default.UserSuspendContributionNotification.method
-    }).then(res => {
-      if (res.status >= 300) {
-        console.log(`Unable to perform action (Response code: ${res.status}).`);
-        return Promise.reject(res);
-      }
-
-      return Promise.resolve(res);
-    }).catch(error => {
-      console.log('Unable to perform action.');
-      return Promise.reject(error);
-    });
+    return (0, _apiRequest.apiRequest)(_Endpoints.default.UserSuspendContributionNotification.url({
+      type,
+      id
+    }), _Endpoints.default.UserSuspendContributionNotification.method);
   }
+  /**
+   * This endpoint returns suspended = true if the notifications for the feed obj (identified in path) is suspended by the authenticated user
+   * @param type
+   * @param id
+   */
+
 
   static checkIfSuspendedFeedObject(type, id) {
-    return _client.default.request({
-      url: _Endpoints.default.UserCheckContributionNotificationSuspended.url({
-        type,
-        id
-      }),
-      method: _Endpoints.default.UserCheckContributionNotificationSuspended.method
-    }).then(res => {
-      if (res.status >= 300) {
-        console.log(`Unable to perform action (Response code: ${res.status}).`);
-        return Promise.reject(res);
-      }
-
-      return Promise.resolve(res);
-    }).catch(error => {
-      console.log('Unable to perform action.');
-      return Promise.reject(error);
-    });
+    return (0, _apiRequest.apiRequest)(_Endpoints.default.UserCheckContributionNotificationSuspended.url({
+      type,
+      id
+    }), _Endpoints.default.UserCheckContributionNotificationSuspended.method);
   }
+  /**
+   * This endpoint retrieves the list of feed obj which notifications are suspended by the authenticated user
+   * @param type
+   * @param params
+   */
 
-  static feedObjectSuspendedList(type) {
-    return _client.default.request({
-      url: _Endpoints.default.UserListContributionNotificationSuspended.url({
-        type
-      }),
-      method: _Endpoints.default.UserListContributionNotificationSuspended.method
-    }).then(res => {
-      if (res.status >= 300) {
-        console.log(`Unable to retrieve suspended feed objects (Response code: ${res.status}).`);
-        return Promise.reject(res);
-      }
-
-      return Promise.resolve(res);
-    }).catch(error => {
-      console.log('Unable to retrieve suspended feed objects.');
-      return Promise.reject(error);
-    });
+
+  static feedObjectSuspendedList(type, params) {
+    const p = new URLSearchParams(params);
+    return (0, _apiRequest.apiRequest)(`${_Endpoints.default.UserListContributionNotificationSuspended.url({
+      type
+    })}?${p.toString()}`, _Endpoints.default.UserListContributionNotificationSuspended.method);
   }
+  /**
+   * This endpoint flags a specific feed obj
+   * @param type
+   * @param id
+   * @param flag_type
+   */
 
-  static flagFeedObject(type, id) {
-    return _client.default.request({
-      url: _Endpoints.default.Flag.url({
-        type,
-        id
-      }),
-      method: _Endpoints.default.Flag.method
-    }).then(res => {
-      if (res.status >= 300) {
-        console.log(`Unable to perform action (Response code: ${res.status}).`);
-        return Promise.reject(res);
-      }
-
-      return Promise.resolve(res);
-    }).catch(error => {
-      console.log('Unable to perform action.');
-      return Promise.reject(error);
-    });
+
+  static flagFeedObject(type, id, flag_type) {
+    return (0, _apiRequest.apiRequest)(_Endpoints.default.Flag.url({
+      type,
+      id
+    }), _Endpoints.default.Flag.method, flag_type);
   }
+  /**
+   * Retrieves, if exists, a flag for this contribute created by the authenticated user
+   * @param type
+   * @param id
+   */
+
 
   static feedObjectFlagStatus(type, id) {
-    return _client.default.request({
-      url: _Endpoints.default.FlagStatus.url({
-        type,
-        id
-      }),
-      method: _Endpoints.default.FlagStatus.method
-    }).then(res => {
-      if (res.status >= 300) {
-        console.log(`Unable to retrieve status (Response code: ${res.status}).`);
-        return Promise.reject(res);
-      }
-
-      return Promise.resolve(res);
-    }).catch(error => {
-      console.log('Unable to retrieve status.');
-      return Promise.reject(error);
-    });
+    return (0, _apiRequest.apiRequest)(_Endpoints.default.FlagStatus.url({
+      type,
+      id
+    }), _Endpoints.default.FlagStatus.method);
   }
+  /**
+   * This endpoint retrieves a list of flags for a specific feed obj
+   * @param type
+   * @param id
+   */
 
-  static feedObjectFlagList(type) {
-    return _client.default.request({
-      url: _Endpoints.default.FeedObjectFlagList.url({
-        type
-      }),
-      method: _Endpoints.default.FeedObjectFlagList.method
-    }).then(res => {
-      if (res.status >= 300) {
-        console.log(`Unable to retrieve flagged feed objects (Response code: ${res.status}).`);
-        return Promise.reject(res);
-      }
-
-      return Promise.resolve(res);
-    }).catch(error => {
-      console.log('Unable to retrieve flagged feed objects.');
-      return Promise.reject(error);
-    });
+
+  static feedObjectFlagList(type, id) {
+    return (0, _apiRequest.apiRequest)(_Endpoints.default.FeedObjectFlagList.url({
+      type,
+      id
+    }), _Endpoints.default.FeedObjectFlagList.method);
   }
+  /**
+   * This endpoint hides the feed obj for the logged user. The feed obj must be in show state
+   * @param type
+   * @param id
+   */
+
 
   static hideFeedObject(type, id) {
-    return _client.default.request({
-      url: _Endpoints.default.HideFeedObject.url({
-        type,
-        id
-      }),
-      method: _Endpoints.default.HideFeedObject.method
-    }).then(res => {
-      if (res.status >= 300) {
-        console.log(`Unable to perform action (Response code: ${res.status}).`);
-        return Promise.reject(res);
-      }
-
-      return Promise.resolve(res);
-    }).catch(error => {
-      console.log('Unable to perform action.');
-      return Promise.reject(error);
-    });
+    return (0, _apiRequest.apiRequest)(_Endpoints.default.HideFeedObject.url({
+      type,
+      id
+    }), _Endpoints.default.HideFeedObject.method);
   }
+  /**
+   * This endpoint retrieves if the the feed obj has been hidden by the authenticated user (hidden = true)
+   * @param type
+   * @param id
+   */
+
 
   static feedObjectHideStatus(type, id) {
-    return _client.default.request({
-      url: _Endpoints.default.FeedObjectHideStatus.url({
-        type,
-        id
-      }),
-      method: _Endpoints.default.FeedObjectHideStatus.method
-    }).then(res => {
-      if (res.status >= 300) {
-        console.log(`Unable to retrieve status (Response code: ${res.status}).`);
-        return Promise.reject(res);
-      }
-
-      return Promise.resolve(res);
-    }).catch(error => {
-      console.log('Unable to retrieve status.');
-      return Promise.reject(error);
-    });
+    return (0, _apiRequest.apiRequest)(_Endpoints.default.FeedObjectHideStatus.url({
+      type,
+      id
+    }), _Endpoints.default.FeedObjectHideStatus.method);
   }
 
 }
@@ -547,76 +381,76 @@ class FeedObjectApiClient {
 exports.FeedObjectApiClient = FeedObjectApiClient;
 
 class FeedObjectService {
-  static async getAllFeedObjects(type) {
-    return FeedObjectApiClient.getAllFeedObjects(type);
+  static async getAllFeedObjects(type, params) {
+    return FeedObjectApiClient.getAllFeedObjects(type, params);
   }
 
-  static async getUncommentedFeedObjects(type) {
-    return FeedObjectApiClient.getUncommentedFeedObjects(type);
+  static async getUncommentedFeedObjects(type, params) {
+    return FeedObjectApiClient.getUncommentedFeedObjects(type, params);
   }
 
   static async searchFeedObject(type) {
     return FeedObjectApiClient.searchFeedObject(type);
   }
 
-  static async createFeedObject(type) {
-    return FeedObjectApiClient.createFeedObject(type);
+  static async createFeedObject(type, data) {
+    return FeedObjectApiClient.createFeedObject(type, data);
   }
 
   static async getSpecificFeedObject(type, id) {
     return FeedObjectApiClient.getSpecificFeedObject(type, id);
   }
 
-  static async updateFeedObject(type, id) {
-    return FeedObjectApiClient.updateFeedObject(type, id);
+  static async updateFeedObject(type, id, data) {
+    return FeedObjectApiClient.updateFeedObject(type, id, data);
   }
 
   static async deleteFeedObject(type, id) {
     return FeedObjectApiClient.deleteFeedObject(type, id);
   }
 
-  static async feedObjectContributorsList(type, id) {
-    return FeedObjectApiClient.feedObjectContributorsList(type, id);
+  static async feedObjectContributorsList(type, id, params) {
+    return FeedObjectApiClient.feedObjectContributorsList(type, id, params);
   }
 
-  static async feedObjectSharesList(type, id) {
-    return FeedObjectApiClient.feedObjectSharesList(type, id);
+  static async feedObjectSharesList(type, id, params) {
+    return FeedObjectApiClient.feedObjectSharesList(type, id, params);
   }
 
-  static async feedObjectUserSharesList(type, id) {
-    return FeedObjectApiClient.feedObjectUserSharesList(type, id);
+  static async feedObjectUserSharesList(type, id, params) {
+    return FeedObjectApiClient.feedObjectUserSharesList(type, id, params);
   }
 
   static async restoreFeedObject(type, id) {
     return FeedObjectApiClient.restoreFeedObject(type, id);
   }
 
-  static async relatedFeedObjects(type, id) {
-    return FeedObjectApiClient.relatedFeedObjects(type, id);
+  static async relatedFeedObjects(type, id, params) {
+    return FeedObjectApiClient.relatedFeedObjects(type, id, params);
   }
 
   static async voteFeedObject(type, id) {
     return FeedObjectApiClient.voteFeedObject(type, id);
   }
 
-  static async feedObjectVotes(type, id) {
-    return FeedObjectApiClient.feedObjectVotes(type, id);
+  static async feedObjectVotes(type, id, params) {
+    return FeedObjectApiClient.feedObjectVotes(type, id, params);
   }
 
-  static async feedObjectPollVote(type, id) {
-    return FeedObjectApiClient.feedObjectPollVote(type, id);
+  static async feedObjectPollVote(type, id, choice) {
+    return FeedObjectApiClient.feedObjectPollVote(type, id, choice);
   }
 
-  static async feedObjectPollVotesList(type, id) {
-    return FeedObjectApiClient.feedObjectPollVotesList(type, id);
+  static async feedObjectPollVotesList(type, id, params) {
+    return FeedObjectApiClient.feedObjectPollVotesList(type, id, params);
   }
 
   static async followFeedObject(type, id) {
     return FeedObjectApiClient.followFeedObject(type, id);
   }
 
-  static async feedObjectFollowingList(type) {
-    return FeedObjectApiClient.feedObjectFollowingList(type);
+  static async feedObjectFollowingList(type, params) {
+    return FeedObjectApiClient.feedObjectFollowingList(type, params);
   }
 
   static async checkIfFollowingFeedObject(type, id) {
@@ -631,16 +465,16 @@ class FeedObjectService {
     return FeedObjectApiClient.checkIfSuspendedFeedObject(type, id);
   }
 
-  static async feedObjectSuspendedList(type) {
-    return FeedObjectApiClient.feedObjectSuspendedList(type);
+  static async feedObjectSuspendedList(type, params) {
+    return FeedObjectApiClient.feedObjectSuspendedList(type, params);
   }
 
-  static async flagFeedObject(type, id) {
-    return FeedObjectApiClient.flagFeedObject(type, id);
+  static async flagFeedObject(type, id, flag_type) {
+    return FeedObjectApiClient.flagFeedObject(type, id, flag_type);
   }
 
-  static async feedObjectFlagList(type) {
-    return FeedObjectApiClient.feedObjectFlagList(type);
+  static async feedObjectFlagList(type, id) {
+    return FeedObjectApiClient.feedObjectFlagList(type, id);
   }
 
   static async feedObjectFlagStatus(type, id) {