@selfcommunity/api-services 0.1.6 → 0.1.7

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

@@ -3,873 +3,526 @@
 exports.__esModule = true;
 exports.default = exports.UserApiClient = 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 users.
+ */
 class UserApiClient {
+  /**
+   * This endpoint retrieves the list of all users
+   */
   static getAllUsers() {
-    return _client.default.request({
-      url: _Endpoints.default.User.url({}),
-      method: _Endpoints.default.User.method
-    }).then(res => {
-      if (res.status >= 300) {
-        console.log(`Unable to retrieve users (Response code: ${res.status}).`);
-        return Promise.reject(res);
-      }
-
-      return Promise.resolve(res);
-    }).catch(error => {
-      console.log('Unable to retrieve users.');
-      return Promise.reject(error);
-    });
+    return (0, _apiRequest.apiRequest)(_Endpoints.default.User.url({}), _Endpoints.default.User.method);
   }
+  /**
+   * This endpoint retrieves the list of all users hidden by the authenticated user
+   */
+
 
   static getHiddenUsers() {
-    return _client.default.request({
-      url: _Endpoints.default.ListHiddenUsers.url(),
-      method: _Endpoints.default.ListHiddenUsers.method
-    }).then(res => {
-      if (res.status >= 300) {
-        console.log(`Unable to retrieve hidden users (Response code: ${res.status}).`);
-        return Promise.reject(res);
-      }
-
-      return Promise.resolve(res.data);
-    }).catch(error => {
-      console.log('Unable to retrieve hidden users.');
-      return Promise.reject(error);
-    });
+    return (0, _apiRequest.apiRequest)(_Endpoints.default.ListHiddenUsers.url(), _Endpoints.default.ListHiddenUsers.method);
   }
+  /**
+   * This endpoint retrieves the list of all users that meet the search criteria. The user object returned will contain only the following attributes: id, username, real_name, ext_id and avatar.
+   * This endpoint is recommended for implementing an autocomplete input field.
+   * @param params
+   */
 
-  static userAutocomplete() {
-    return _client.default.request({
-      url: _Endpoints.default.UserAutocomplete.url(),
-      method: _Endpoints.default.UserAutocomplete.method
-    }).then(res => {
-      if (res.status >= 300) {
-        console.log(`Unable to retrieve users (Response code: ${res.status}).`);
-        return Promise.reject(res);
-      }
-
-      return Promise.resolve(res.data);
-    }).catch(error => {
-      console.log('Unable to retrieve users.');
-      return Promise.reject(error);
-    });
+
+  static userAutocomplete(params) {
+    const p = new URLSearchParams(params);
+    return (0, _apiRequest.apiRequest)(`${_Endpoints.default.UserAutocomplete.url()}?${p.toString()})}`, _Endpoints.default.UserAutocomplete.method);
   }
+  /**
+   * This endpoint performs users search.
+   * @param params
+   */
 
-  static userSearch() {
-    return _client.default.request({
-      url: _Endpoints.default.UserSearch.url(),
-      method: _Endpoints.default.UserSearch.method
-    }).then(res => {
-      if (res.status >= 300) {
-        console.log(`Unable to retrieve users (Response code: ${res.status}).`);
-        return Promise.reject(res);
-      }
-
-      return Promise.resolve(res.data);
-    }).catch(error => {
-      console.log('Unable to retrieve users .');
-      return Promise.reject(error);
-    });
+
+  static userSearch(params) {
+    const p = new URLSearchParams(params);
+    return (0, _apiRequest.apiRequest)(`${_Endpoints.default.UserSearch.url()}?${p.toString()})}`, _Endpoints.default.UserSearch.method);
   }
+  /**
+   * This endpoint retrieves a specific user's profile identified by ID.
+   * @param id
+   */
+
 
   static getSpecificUser(id) {
-    return _client.default.request({
-      url: _Endpoints.default.User.url({
-        id
-      }),
-      method: _Endpoints.default.User.method
-    }).then(res => {
-      if (res.status >= 300) {
-        console.log(`Unable to retrieve user (Response code: ${res.status}).`);
-        return Promise.reject(res);
-      }
-
-      return Promise.resolve(res);
-    }).catch(error => {
-      console.log('Unable to retrieve user.');
-      return Promise.reject(error);
-    });
+    return (0, _apiRequest.apiRequest)(_Endpoints.default.User.url({
+      id
+    }), _Endpoints.default.User.method);
   }
+  /**
+   * This endpoint retrieves the counters of a specific user identified by Id.
+   * @param id
+   */
+
 
   static getUserCounters(id) {
-    return _client.default.request({
-      url: _Endpoints.default.UserCounters.url({
-        id
-      }),
-      method: _Endpoints.default.UserCounters.method
-    }).then(res => {
-      if (res.status >= 300) {
-        console.log(`Unable to retrieve counters (Response code: ${res.status}).`);
-        return Promise.reject(res);
-      }
-
-      return Promise.resolve(res.data);
-    }).catch(error => {
-      console.log('Unable to retrieve counters.');
-      return Promise.reject(error);
-    });
+    return (0, _apiRequest.apiRequest)(_Endpoints.default.UserCounters.url({
+      id
+    }), _Endpoints.default.UserCounters.method);
   }
+  /**
+   * This endpoint updates the profile of a user identified by ID. A user can only update their personal data.
+   * @param id
+   * @param data
+   */
 
-  static userUpdate(id) {
-    return _client.default.request({
-      url: _Endpoints.default.UserUpdate.url({
-        id
-      }),
-      method: _Endpoints.default.UserUpdate.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.data);
-    }).catch(error => {
-      console.log('Unable to perform action.');
-      return Promise.reject(error);
-    });
+
+  static userUpdate(id, data) {
+    return (0, _apiRequest.apiRequest)(_Endpoints.default.UserUpdate.url({
+      id
+    }), _Endpoints.default.UserUpdate.method, data != null ? data : null);
   }
+  /**
+   * This endpoint patches a specific user identified by {id}
+   * @param id
+   * @param data
+   */
 
-  static userPatch(id) {
-    return _client.default.request({
-      url: _Endpoints.default.UserPatch.url({
-        id
-      }),
-      method: _Endpoints.default.UserPatch.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.data);
-    }).catch(error => {
-      console.log('Unable to perform action.');
-      return Promise.reject(error);
-    });
+
+  static userPatch(id, data) {
+    return (0, _apiRequest.apiRequest)(_Endpoints.default.UserPatch.url({
+      id
+    }), _Endpoints.default.UserPatch.method, data != null ? data : null);
   }
+  /**
+   * This endpoint deletes a specific user identified by {id}
+   * @param id
+   * @param hard
+   */
 
-  static userDelete(id) {
-    return _client.default.request({
-      url: _Endpoints.default.UserDelete.url({
-        id
-      }),
-      method: _Endpoints.default.UserDelete.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.data);
-    }).catch(error => {
-      console.log('Unable to perform action.');
-      return Promise.reject(error);
-    });
+
+  static userDelete(id, hard) {
+    return (0, _apiRequest.apiRequest)(`${_Endpoints.default.UserDelete.url({
+      id
+    })}?${hard.toString()})}`, _Endpoints.default.UserDelete.method);
   }
+  /**
+   * This endpoint changes the email of the authenticated user.
+   * @param id
+   * @param new_email
+   * @param confirm
+   */
 
-  static changeUserMail(id) {
-    return _client.default.request({
-      url: _Endpoints.default.ChangeUserMail.url({
-        id
-      }),
-      method: _Endpoints.default.ChangeUserMail.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.data);
-    }).catch(error => {
-      console.log('Unable to perform action.');
-      return Promise.reject(error);
+
+  static changeUserMail(id, new_email, confirm) {
+    return (0, _apiRequest.apiRequest)(_Endpoints.default.ChangeUserMail.url({
+      id
+    }), _Endpoints.default.ChangeUserMail.method, {
+      new_email: new_email,
+      confirm: confirm != null ? confirm : null
     });
   }
+  /**
+   * This endpoint confirms email change.
+   * @param id
+   * @param new_email
+   * @param validation_code
+   */
+
 
-  static confirmChangeUserMail(id) {
-    return _client.default.request({
-      url: _Endpoints.default.ConfirmUserChangeMail.url({
-        id
-      }),
-      method: _Endpoints.default.ConfirmUserChangeMail.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.data);
-    }).catch(error => {
-      console.log('Unable to perform action.');
-      return Promise.reject(error);
+  static confirmChangeUserMail(id, new_email, validation_code) {
+    return (0, _apiRequest.apiRequest)(_Endpoints.default.ConfirmUserChangeMail.url({
+      id
+    }), _Endpoints.default.ConfirmUserChangeMail.method, {
+      new_email: new_email,
+      validation_code: validation_code
     });
   }
+  /**
+   * This endpoint changes the password of the authenticated user.
+   * @param id
+   * @param password
+   * @param new_password
+   */
+
 
-  static changeUserPassword(id) {
-    return _client.default.request({
-      url: _Endpoints.default.ChangeUserPassword.url({
-        id
-      }),
-      method: _Endpoints.default.ChangeUserPassword.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.data);
-    }).catch(error => {
-      console.log('Unable to perform action.');
-      return Promise.reject(error);
+  static changeUserPassword(id, password, new_password) {
+    return (0, _apiRequest.apiRequest)(_Endpoints.default.ChangeUserPassword.url({
+      id
+    }), _Endpoints.default.ChangeUserPassword.method, {
+      password: password,
+      new_password: new_password
     });
   }
+  /**
+   * This endpoint retrieves all current user's settings for the authenticated user.
+   * @param id
+   */
+
 
   static userSettings(id) {
-    return _client.default.request({
-      url: _Endpoints.default.UserSettings.url({
-        id
-      }),
-      method: _Endpoints.default.UserSettings.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.data);
-    }).catch(error => {
-      console.log('Unable to perform action.');
-      return Promise.reject(error);
-    });
+    return (0, _apiRequest.apiRequest)(_Endpoints.default.UserSettings.url({
+      id
+    }), _Endpoints.default.UserSettings.method);
   }
+  /**
+   * This endpoint changes the user settings for the authenticated user.
+   * @param id
+   * @param data
+   */
 
-  static userSettingsPatch(id) {
-    return _client.default.request({
-      url: _Endpoints.default.UserSettingsPatch.url({
-        id
-      }),
-      method: _Endpoints.default.UserSettingsPatch.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.data);
-    }).catch(error => {
-      console.log('Unable to perform action.');
-      return Promise.reject(error);
-    });
+
+  static userSettingsPatch(id, data) {
+    return (0, _apiRequest.apiRequest)(_Endpoints.default.UserSettingsPatch.url({
+      id
+    }), _Endpoints.default.UserSettingsPatch.method, data != null ? data : null);
   }
+  /**
+   * This endpoint returns the user identified by the authentication token.
+   */
+
 
   static getCurrentUser() {
-    return _client.default.request({
-      url: _Endpoints.default.Me.url(),
-      method: _Endpoints.default.Me.method
-    }).then(res => {
-      if (res.status >= 300) {
-        console.log(`Unable to retrieve user (Response code: ${res.status}).`);
-        return Promise.reject(res);
-      }
-
-      return Promise.resolve(res.data);
-    }).catch(error => {
-      console.log('Unable to retrieve user profile.');
-      return Promise.reject(error);
-    });
+    return (0, _apiRequest.apiRequest)(_Endpoints.default.Me.url(), _Endpoints.default.Me.method);
   }
+  /**
+   * This endpoint returns the url to the user's current avatar.
+   */
+
 
   static getCurrentUserAvatar() {
-    return _client.default.request({
-      url: _Endpoints.default.MyAvatar.url({}),
-      method: _Endpoints.default.MyAvatar.method
-    }).then(res => {
-      if (res.status >= 300) {
-        console.log(`Unable to retrieve user avatar (Response code: ${res.status}).`);
-        return Promise.reject(res);
-      }
-
-      return Promise.resolve(res.data);
-    }).catch(error => {
-      console.log('Unable to retrieve user avatar.');
-      return Promise.reject(error);
-    });
+    return (0, _apiRequest.apiRequest)(_Endpoints.default.MyAvatar.url({}), _Endpoints.default.MyAvatar.method);
   }
+  /**
+   * This endpoint returns a list of permissions for the user identified by the authentication token. Some of the permissions in the list depend on global community settings.
+   */
+
 
   static getCurrentUserPermission() {
-    return _client.default.request({
-      url: _Endpoints.default.Permission.url({}),
-      method: _Endpoints.default.Permission.method
-    }).then(res => {
-      if (res.status >= 300) {
-        console.log(`Unable to retrieve user permissions (Response code: ${res.status}).`);
-        return Promise.reject(res);
-      }
-
-      return Promise.resolve(res.data);
-    }).catch(error => {
-      console.log('Unable to retrieve user permissions.');
-      return Promise.reject(error);
-    });
+    return (0, _apiRequest.apiRequest)(_Endpoints.default.Permission.url({}), _Endpoints.default.Permission.method);
   }
+  /**
+   * This endpoint retrieves the platform url starting from the Authorization user token. Using this url, the logged user (must be a staff member) can access the platform to manage the community.
+   */
+
 
   static getCurrentUserPlatform() {
-    return _client.default.request({
-      url: _Endpoints.default.Platform.url({}),
-      method: _Endpoints.default.Platform.method
-    }).then(res => {
-      if (res.status >= 300) {
-        console.log(`Unable to retrieve platform (Response code: ${res.status}).`);
-        return Promise.reject(res);
-      }
-
-      return Promise.resolve(res.data);
-    }).catch(error => {
-      console.log('Unable to retrieve platform.');
-      return Promise.reject(error);
-    });
+    return (0, _apiRequest.apiRequest)(_Endpoints.default.Platform.url({}), _Endpoints.default.Platform.method);
   }
+  /**
+   * This endpoint gets the list of categories followed by the user.
+   * @param id
+   * @param mutual
+   */
 
-  static getUserFollowedCategories(id) {
-    return _client.default.request({
-      url: _Endpoints.default.FollowedCategories.url({
-        id
-      }),
-      method: _Endpoints.default.FollowedCategories.method
-    }).then(res => {
-      if (res.status >= 300) {
-        console.log(`Unable to retrieve categories followed (Response code: ${res.status}).`);
-        return Promise.reject(res);
-      }
-
-      return Promise.resolve(res.data);
-    }).catch(error => {
-      console.log('Unable to retrieve categories followed.');
-      return Promise.reject(error);
-    });
+
+  static getUserFollowedCategories(id, mutual) {
+    return (0, _apiRequest.apiRequest)(`${_Endpoints.default.FollowedCategories.url({
+      id
+    })}?${mutual.toString()})}`, _Endpoints.default.FollowedCategories.method);
   }
+  /**
+   * This endpoint retrieves the list of posts of the user identified by {id}
+   * @param id
+   */
+
 
   static getUserFeed(id) {
-    return _client.default.request({
-      url: _Endpoints.default.UserFeed.url({
-        id
-      }),
-      method: _Endpoints.default.UserFeed.method
-    }).then(res => {
-      if (res.status >= 300) {
-        console.log(`Unable to retrieve user feed (Response code: ${res.status}).`);
-        return Promise.reject(res);
-      }
-
-      return Promise.resolve(res.data);
-    }).catch(error => {
-      console.log('Unable to retrieve user feed.');
-      return Promise.reject(error);
-    });
+    return (0, _apiRequest.apiRequest)(_Endpoints.default.UserFeed.url({
+      id
+    }), _Endpoints.default.UserFeed.method);
   }
+  /**
+   * This endpoint retrieves the list of followers of a specific user identified by {id}
+   * @param id
+   * @param mutual
+   */
 
-  static getUserFollowers(id) {
-    return _client.default.request({
-      url: _Endpoints.default.UserFollowers.url({
-        id
-      }),
-      method: _Endpoints.default.UserFollowers.method
-    }).then(res => {
-      if (res.status >= 300) {
-        console.log(`Unable to retrieve user followers (Response code: ${res.status}).`);
-        return Promise.reject(res);
-      }
-
-      return Promise.resolve(res.data);
-    }).catch(error => {
-      console.log('Unable to retrieve user followers.');
-      return Promise.reject(error);
-    });
+
+  static getUserFollowers(id, mutual) {
+    return (0, _apiRequest.apiRequest)(`${_Endpoints.default.UserFollowers.url({
+      id
+    })}?${mutual.toString()})}`, _Endpoints.default.UserFollowers.method);
   }
+  /**
+   * This endpoint retrieves the list of following of a specific user identified by {id}.
+   * @param id
+   * @param mutual
+   */
 
-  static getUserFollowed(id) {
-    return _client.default.request({
-      url: _Endpoints.default.UserFollowed.url({
-        id
-      }),
-      method: _Endpoints.default.UserFollowed.method
-    }).then(res => {
-      if (res.status >= 300) {
-        console.log(`Unable to retrieve user followings (Response code: ${res.status}).`);
-        return Promise.reject(res);
-      }
-
-      return Promise.resolve(res.data);
-    }).catch(error => {
-      console.log('Unable to retrieve user followings.');
-      return Promise.reject(error);
-    });
+
+  static getUserFollowed(id, mutual) {
+    return (0, _apiRequest.apiRequest)(`${_Endpoints.default.UserFollowed.url({
+      id
+    })}?${mutual.toString()})`, _Endpoints.default.UserFollowed.method);
   }
+  /**
+   * This endpoint allows a user to follow another user identified by {id}
+   * @param id
+   */
+
 
   static followUser(id) {
-    return _client.default.request({
-      url: _Endpoints.default.FollowUser.url({
-        id
-      }),
-      method: _Endpoints.default.FollowUser.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.data);
-    }).catch(error => {
-      console.log('Unable to perform action.');
-      return Promise.reject(error);
-    });
+    return (0, _apiRequest.apiRequest)(_Endpoints.default.FollowUser.url({
+      id
+    }), _Endpoints.default.FollowUser.method);
   }
+  /**
+   * This endpoint returns is_followed = true if the user (identified in path) is followed by me.
+   * @param id
+   */
+
 
   static checkUserFollowed(id) {
-    return _client.default.request({
-      url: _Endpoints.default.CheckUserFollowed.url({
-        id
-      }),
-      method: _Endpoints.default.CheckUserFollowed.method
-    }).then(res => {
-      if (res.status >= 300) {
-        console.log(`Unable to retrieve users (Response code: ${res.status}).`);
-        return Promise.reject(res);
-      }
-
-      return Promise.resolve(res.data);
-    }).catch(error => {
-      console.log('Unable to retrieve users .');
-      return Promise.reject(error);
-    });
+    return (0, _apiRequest.apiRequest)(_Endpoints.default.CheckUserFollowed.url({
+      id
+    }), _Endpoints.default.CheckUserFollowed.method);
   }
+  /**
+   * This endpoint returns is_follower = true if the user (identified in path) follow me
+   * @param id
+   */
+
 
   static checkUserFollower(id) {
-    return _client.default.request({
-      url: _Endpoints.default.CheckUserFollower.url({
-        id
-      }),
-      method: _Endpoints.default.CheckUserFollower.method
-    }).then(res => {
-      if (res.status >= 300) {
-        console.log(`Unable to retrieve users (Response code: ${res.status}).`);
-        return Promise.reject(res);
-      }
-
-      return Promise.resolve(res.data);
-    }).catch(error => {
-      console.log('Unable to retrieve users .');
-      return Promise.reject(error);
-    });
+    return (0, _apiRequest.apiRequest)(_Endpoints.default.CheckUserFollower.url({
+      id
+    }), _Endpoints.default.CheckUserFollower.method);
   }
+  /**
+   * This endpoint retrieves the list of connections of a specific user identified by ID.
+   * @param id
+   * @param mutual
+   */
 
-  static getUserConnections(id) {
-    return _client.default.request({
-      url: _Endpoints.default.UserConnections.url({
-        id
-      }),
-      method: _Endpoints.default.UserConnections.method
-    }).then(res => {
-      if (res.status >= 300) {
-        console.log(`Unable to retrieve user connections (Response code: ${res.status}).`);
-        return Promise.reject(res);
-      }
-
-      return Promise.resolve(res.data);
-    }).catch(error => {
-      console.log('Unable to retrieve user connections.');
-      return Promise.reject(error);
-    });
+
+  static getUserConnections(id, mutual) {
+    return (0, _apiRequest.apiRequest)(`${_Endpoints.default.UserConnections.url({
+      id
+    })}?${mutual.toString()})`, _Endpoints.default.UserConnections.method);
   }
+  /**
+   * This endpoint returns is_connection = true if the user (identified in path) is connected with me.
+   * @param id
+   */
+
 
   static checkUserConnections(id) {
-    return _client.default.request({
-      url: _Endpoints.default.UserCheckConnection.url({
-        id
-      }),
-      method: _Endpoints.default.UserCheckConnection.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.data);
-    }).catch(error => {
-      console.log('Unable to perform action.');
-      return Promise.reject(error);
-    });
+    return (0, _apiRequest.apiRequest)(_Endpoints.default.UserCheckConnection.url({
+      id
+    }), _Endpoints.default.UserCheckConnection.method);
   }
+  /**
+   * This endpoint retrieves the list of connection requests received by a specific user identified by ID.
+   * @param id
+   */
+
 
   static getUserConnectionRequests(id) {
-    return _client.default.request({
-      url: _Endpoints.default.UserConnectionRequests.url({
-        id
-      }),
-      method: _Endpoints.default.UserConnectionRequests.method
-    }).then(res => {
-      if (res.status >= 300) {
-        console.log(`Unable to retrieve user connection requests (Response code: ${res.status}).`);
-        return Promise.reject(res);
-      }
-
-      return Promise.resolve(res.data);
-    }).catch(error => {
-      console.log('Unable to retrieve user connection requests.');
-      return Promise.reject(error);
-    });
+    return (0, _apiRequest.apiRequest)(_Endpoints.default.UserConnectionRequests.url({
+      id
+    }), _Endpoints.default.UserConnectionRequests.method);
   }
+  /**
+   * This endpoint retrieves a specific user's list of connection requests sent by user.
+   * @param id
+   */
+
 
   static getUserRequestConnectionsSent(id) {
-    return _client.default.request({
-      url: _Endpoints.default.UserRequestConnectionsSent.url({
-        id
-      }),
-      method: _Endpoints.default.UserRequestConnectionsSent.method
-    }).then(res => {
-      if (res.status >= 300) {
-        console.log(`Unable to retrieve user connection requests sent (Response code: ${res.status}).`);
-        return Promise.reject(res);
-      }
-
-      return Promise.resolve(res.data);
-    }).catch(error => {
-      console.log('Unable to retrieve user connection requests sent.');
-      return Promise.reject(error);
-    });
+    return (0, _apiRequest.apiRequest)(_Endpoints.default.UserRequestConnectionsSent.url({
+      id
+    }), _Endpoints.default.UserRequestConnectionsSent.method);
   }
+  /**
+   * This endpoint accepts a request connection of the user identified by {id}
+   * @param id
+   */
+
 
   static userAcceptRequestConnection(id) {
-    return _client.default.request({
-      url: _Endpoints.default.UserAcceptRequestConnection.url({
-        id
-      }),
-      method: _Endpoints.default.UserAcceptRequestConnection.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.data);
-    }).catch(error => {
-      console.log('Unable to perform action.');
-      return Promise.reject(error);
-    });
+    return (0, _apiRequest.apiRequest)(_Endpoints.default.UserAcceptRequestConnection.url({
+      id
+    }), _Endpoints.default.UserAcceptRequestConnection.method);
   }
+  /**
+   * This endpoint requests a connection to the user identified by {id}
+   * @param id
+   */
+
 
   static userRequestConnection(id) {
-    return _client.default.request({
-      url: _Endpoints.default.UserRequestConnection.url({
-        id
-      }),
-      method: _Endpoints.default.UserRequestConnection.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.data);
-    }).catch(error => {
-      console.log('Unable to perform action.');
-      return Promise.reject(error);
-    });
+    return (0, _apiRequest.apiRequest)(_Endpoints.default.UserRequestConnection.url({
+      id
+    }), _Endpoints.default.UserRequestConnection.method);
   }
+  /**
+   * This endpoint removes connection with the user identified by {id}
+   * @param id
+   */
+
 
   static userRemoveConnection(id) {
-    return _client.default.request({
-      url: _Endpoints.default.UserRemoveConnection.url({
-        id
-      }),
-      method: _Endpoints.default.UserRemoveConnection.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.data);
-    }).catch(error => {
-      console.log('Unable to perform action.');
-      return Promise.reject(error);
-    });
+    return (0, _apiRequest.apiRequest)(_Endpoints.default.UserRemoveConnection.url({
+      id
+    }), _Endpoints.default.UserRemoveConnection.method);
   }
+  /**
+   * This endpoint cancels reject connection to a user identified by {id}
+   * @param id
+   */
+
 
   static userCancelRejectConnectionRequest(id) {
-    return _client.default.request({
-      url: _Endpoints.default.UserCancelRejectConnectionRequest.url({
-        id
-      }),
-      method: _Endpoints.default.UserCancelRejectConnectionRequest.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.data);
-    }).catch(error => {
-      console.log('Unable to perform action.');
-      return Promise.reject(error);
-    });
+    return (0, _apiRequest.apiRequest)(_Endpoints.default.UserCancelRejectConnectionRequest.url({
+      id
+    }), _Endpoints.default.UserCancelRejectConnectionRequest.method);
   }
+  /**
+   * This endpoint cancels a request connection for a user.
+   * @param id
+   */
+
 
   static userCancelRequestConnection(id) {
-    return _client.default.request({
-      url: _Endpoints.default.UserCancelRequestConnection.url({
-        id
-      }),
-      method: _Endpoints.default.UserCancelRequestConnection.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.data);
-    }).catch(error => {
-      console.log('Unable to perform action.');
-      return Promise.reject(error);
-    });
+    return (0, _apiRequest.apiRequest)(_Endpoints.default.UserCancelRequestConnection.url({
+      id
+    }), _Endpoints.default.UserCancelRequestConnection.method);
   }
+  /**
+   * This endpoint rejects a connection request sent from user identified by {id}
+   * @param id
+   */
+
 
   static userRejectConnectionRequest(id) {
-    return _client.default.request({
-      url: _Endpoints.default.UserRejectConnectionRequest.url({
-        id
-      }),
-      method: _Endpoints.default.UserRejectConnectionRequest.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.data);
-    }).catch(error => {
-      console.log('Unable to perform action.');
-      return Promise.reject(error);
-    });
+    return (0, _apiRequest.apiRequest)(_Endpoints.default.UserRejectConnectionRequest.url({
+      id
+    }), _Endpoints.default.UserRejectConnectionRequest.method);
   }
+  /**
+   * This endpoint marks seen a connection request of user identified by {id} for the authenticated user.
+   * @param id
+   */
+
 
   static userMarkSeenConnectionRequest(id) {
-    return _client.default.request({
-      url: _Endpoints.default.UserMarkSeenConnectionRequest.url({
-        id
-      }),
-      method: _Endpoints.default.UserMarkSeenConnectionRequest.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.data);
-    }).catch(error => {
-      console.log('Unable to perform action.');
-      return Promise.reject(error);
-    });
+    return (0, _apiRequest.apiRequest)(_Endpoints.default.UserMarkSeenConnectionRequest.url({
+      id
+    }), _Endpoints.default.UserMarkSeenConnectionRequest.method);
   }
+  /**
+   * This endpoint shows/hides a user (and its posts) identified by {id} for the authenticated user.
+   * @param id
+   */
+
 
   static showHideUser(id) {
-    return _client.default.request({
-      url: _Endpoints.default.UserShowHide.url({
-        id
-      }),
-      method: _Endpoints.default.UserShowHide.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.data);
-    }).catch(error => {
-      console.log('Unable to perform action.');
-      return Promise.reject(error);
-    });
+    return (0, _apiRequest.apiRequest)(_Endpoints.default.UserShowHide.url({
+      id
+    }), _Endpoints.default.UserShowHide.method);
   }
+  /**
+   * This endpoint returns true if the user (identified in path) is hidden by the authenticated user.
+   * @param id
+   */
+
 
   static checkUserHidden(id) {
-    return _client.default.request({
-      url: _Endpoints.default.CheckUserHidden.url({
-        id
-      }),
-      method: _Endpoints.default.CheckUserHidden.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.data);
-    }).catch(error => {
-      console.log('Unable to perform action.');
-      return Promise.reject(error);
-    });
+    return (0, _apiRequest.apiRequest)(_Endpoints.default.CheckUserHidden.url({
+      id
+    }), _Endpoints.default.CheckUserHidden.method);
   }
+  /**
+   * This endpoint returns true if the user (identified in path) has hidden by the authenticated user.
+   * @param id
+   */
+
 
   static checkUserHiddenBy(id) {
-    return _client.default.request({
-      url: _Endpoints.default.CheckUserHiddenBy.url({
-        id
-      }),
-      method: _Endpoints.default.CheckUserHiddenBy.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.data);
-    }).catch(error => {
-      console.log('Unable to perform action.');
-      return Promise.reject(error);
-    });
+    return (0, _apiRequest.apiRequest)(_Endpoints.default.CheckUserHiddenBy.url({
+      id
+    }), _Endpoints.default.CheckUserHiddenBy.method);
   }
+  /**
+   * This endpoint returns user's loyalty points.
+   * @param id
+   */
+
 
   static getUserLoyaltyPoints(id) {
-    return _client.default.request({
-      url: _Endpoints.default.GetUserLoyaltyPoints.url({
-        id
-      }),
-      method: _Endpoints.default.GetUserLoyaltyPoints.method
-    }).then(res => {
-      if (res.status >= 300) {
-        console.log(`Unable to retrieve user loyalty points (Response code: ${res.status}).`);
-        return Promise.reject(res);
-      }
-
-      return Promise.resolve(res.data);
-    }).catch(error => {
-      console.log('Unable to retrieve user loyalty points.');
-      return Promise.reject(error);
-    });
+    return (0, _apiRequest.apiRequest)(_Endpoints.default.GetUserLoyaltyPoints.url({
+      id
+    }), _Endpoints.default.GetUserLoyaltyPoints.method);
   }
+  /**
+   * This endpoint lists the connection/follow statuses of the logged user starting from a users array.
+   * @param users
+   */
 
-  static getUserConnectionStatuses() {
-    return _client.default.request({
-      url: _Endpoints.default.UserConnectionStatuses.url({}),
-      method: _Endpoints.default.UserConnectionStatuses.method
-    }).then(res => {
-      if (res.status >= 300) {
-        console.log(`Unable to retrieve user connection statuses (Response code: ${res.status}).`);
-        return Promise.reject(res);
-      }
-
-      return Promise.resolve(res.data);
-    }).catch(error => {
-      console.log('Unable to retrieve user connection statuses.');
-      return Promise.reject(error);
+
+  static getUserConnectionStatuses(users) {
+    return (0, _apiRequest.apiRequest)(_Endpoints.default.UserConnectionStatuses.url({}), _Endpoints.default.UserConnectionStatuses.method, {
+      users: users
     });
   }
+  /**
+   * This endpoint returns user's tags to address a contribution.
+   */
+
 
   static userTagToAddressContribution() {
-    return _client.default.request({
-      url: _Endpoints.default.UserTagToAddressContribution.url({}),
-      method: _Endpoints.default.UserTagToAddressContribution.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.data);
-    }).catch(error => {
-      console.log('Unable to perform action.');
-      return Promise.reject(error);
-    });
+    return (0, _apiRequest.apiRequest)(_Endpoints.default.UserTagToAddressContribution.url({}), _Endpoints.default.UserTagToAddressContribution.method);
   }
+  /**
+   * This endpoint checks an email token.
+   */
+
 
   static checkUserEmailToken() {
-    return _client.default.request({
-      url: _Endpoints.default.CheckEmailToken.url({}),
-      method: _Endpoints.default.CheckEmailToken.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.data);
-    }).catch(error => {
-      console.log('Unable to perform action.');
-      return Promise.reject(error);
-    });
+    return (0, _apiRequest.apiRequest)(_Endpoints.default.CheckEmailToken.url({}), _Endpoints.default.CheckEmailToken.method);
   }
+  /**
+   * This endpoint adds an avatar to my avatars.
+   * @param avatar
+   */
 
-  static addUserAvatar() {
-    return _client.default.request({
-      url: _Endpoints.default.AddAvatar.url({}),
-      method: _Endpoints.default.AddAvatar.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.data);
-    }).catch(error => {
-      console.log('Unable to perform action.');
-      return Promise.reject(error);
+
+  static addUserAvatar(avatar) {
+    return (0, _apiRequest.apiRequest)(_Endpoints.default.AddAvatar.url({}), _Endpoints.default.AddAvatar.method, {
+      'Content-Type': 'multipart/form-data'
+    }, {
+      avatar: avatar
     });
   }
+  /**
+   * This endpoint retrieves all user avatars.
+   */
+
 
   static getUserAvatars() {
-    return _client.default.request({
-      url: _Endpoints.default.GetAvatars.url({}),
-      method: _Endpoints.default.GetAvatars.method
-    }).then(res => {
-      if (res.status >= 300) {
-        console.log(`Unable to retrieve user avatars (Response code: ${res.status}).`);
-        return Promise.reject(res);
-      }
-
-      return Promise.resolve(res.data);
-    }).catch(error => {
-      console.log('Unable to retrieve user avatars.');
-      return Promise.reject(error);
-    });
+    return (0, _apiRequest.apiRequest)(_Endpoints.default.GetAvatars.url({}), _Endpoints.default.GetAvatars.method);
   }
+  /**
+   * This endpoint removes/deletes an avatar from the authenticated user avatars.
+   * @param avatar_id
+   */
 
-  static removeUserAvatar() {
-    return _client.default.request({
-      url: _Endpoints.default.RemoveAvatar.url({}),
-      method: _Endpoints.default.RemoveAvatar.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.data);
-    }).catch(error => {
-      console.log('Unable to perform action.');
-      return Promise.reject(error);
+
+  static removeUserAvatar(avatar_id) {
+    return (0, _apiRequest.apiRequest)(_Endpoints.default.RemoveAvatar.url({}), _Endpoints.default.RemoveAvatar.method, {
+      avatar_id: avatar_id
     });
   }
+  /**
+   * This endpoint sets the primary avatar for the authenticated user.
+   * @param avatar_id
+   */
+
 
-  static setUserPrimaryAvatar() {
-    return _client.default.request({
-      url: _Endpoints.default.SetPrimaryAvatar.url({}),
-      method: _Endpoints.default.SetPrimaryAvatar.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.data);
-    }).catch(error => {
-      console.log('Unable to perform action.');
-      return Promise.reject(error);
+  static setUserPrimaryAvatar(avatar_id) {
+    return (0, _apiRequest.apiRequest)(_Endpoints.default.SetPrimaryAvatar.url({}), _Endpoints.default.SetPrimaryAvatar.method, {
+      avatar_id: avatar_id
     });
   }
 
@@ -886,12 +539,12 @@ class UserService {
     return UserApiClient.getHiddenUsers();
   }
 
-  static async userAutocomplete() {
-    return UserApiClient.userAutocomplete();
+  static async userAutocomplete(params) {
+    return UserApiClient.userAutocomplete(params);
   }
 
-  static async userSearch() {
-    return UserApiClient.userSearch();
+  static async userSearch(params) {
+    return UserApiClient.userSearch(params);
   }
 
   static async getSpecificUser(id) {
@@ -902,36 +555,36 @@ class UserService {
     return UserApiClient.getUserCounters(id);
   }
 
-  static async userUpdate(id) {
-    return UserApiClient.userUpdate(id);
+  static async userUpdate(id, data) {
+    return UserApiClient.userUpdate(id, data);
   }
 
-  static async userPatch(id) {
-    return UserApiClient.userPatch(id);
+  static async userPatch(id, data) {
+    return UserApiClient.userPatch(id, data);
   }
 
-  static async userDelete(id) {
-    return UserApiClient.userDelete(id);
+  static async userDelete(id, hard) {
+    return UserApiClient.userDelete(id, hard);
   }
 
-  static async changeUserMail(id) {
-    return UserApiClient.changeUserMail(id);
+  static async changeUserMail(id, new_email, confirm) {
+    return UserApiClient.changeUserMail(id, new_email, confirm);
   }
 
-  static async confirmChangeUserMail(id) {
-    return UserApiClient.confirmChangeUserMail(id);
+  static async confirmChangeUserMail(id, new_email, validation_code) {
+    return UserApiClient.confirmChangeUserMail(id, new_email, validation_code);
   }
 
-  static async changeUserPassword(id) {
-    return UserApiClient.changeUserPassword(id);
+  static async changeUserPassword(id, password, new_password) {
+    return UserApiClient.changeUserPassword(id, password, new_password);
   }
 
   static async userSettings(id) {
     return UserApiClient.userSettings(id);
   }
 
-  static async userSettingsPatch(id) {
-    return UserApiClient.userSettingsPatch(id);
+  static async userSettingsPatch(id, data) {
+    return UserApiClient.userSettingsPatch(id, data);
   }
 
   static async getCurrentUser() {
@@ -950,20 +603,20 @@ class UserService {
     return UserApiClient.getCurrentUserPlatform();
   }
 
-  static async getUserFollowedCategories(id) {
-    return UserApiClient.getUserFollowedCategories(id);
+  static async getUserFollowedCategories(id, mutual) {
+    return UserApiClient.getUserFollowedCategories(id, mutual);
   }
 
   static async getUserFeed(id) {
     return UserApiClient.getUserFeed(id);
   }
 
-  static async getUserFollowers(id) {
-    return UserApiClient.getUserFollowers(id);
+  static async getUserFollowers(id, mutual) {
+    return UserApiClient.getUserFollowers(id, mutual);
   }
 
-  static async getUserFollowed(id) {
-    return UserApiClient.getUserFollowed(id);
+  static async getUserFollowed(id, mutual) {
+    return UserApiClient.getUserFollowed(id, mutual);
   }
 
   static async followUser(id) {
@@ -978,8 +631,8 @@ class UserService {
     return UserApiClient.checkUserFollower(id);
   }
 
-  static async getUserConnections(id) {
-    return UserApiClient.getUserConnections(id);
+  static async getUserConnections(id, mutual) {
+    return UserApiClient.getUserConnections(id, mutual);
   }
 
   static async checkUserConnections(id) {
@@ -1038,8 +691,8 @@ class UserService {
     return UserApiClient.getUserLoyaltyPoints(id);
   }
 
-  static async getUserConnectionStatuses() {
-    return UserApiClient.getUserConnectionStatuses();
+  static async getUserConnectionStatuses(users) {
+    return UserApiClient.getUserConnectionStatuses(users);
   }
 
   static async userTagToAddressContribution() {
@@ -1050,20 +703,20 @@ class UserService {
     return UserApiClient.checkUserEmailToken();
   }
 
-  static async addUserAvatar() {
-    return UserApiClient.addUserAvatar();
+  static async addUserAvatar(avatar) {
+    return UserApiClient.addUserAvatar(avatar);
   }
 
   static async getUserAvatars() {
     return UserApiClient.getUserAvatars();
   }
 
-  static async removeUserAvatar() {
-    return UserApiClient.removeUserAvatar();
+  static async removeUserAvatar(avatar_id) {
+    return UserApiClient.removeUserAvatar(avatar_id);
   }
 
-  static async setUserPrimaryAvatar() {
-    return UserApiClient.setUserPrimaryAvatar();
+  static async setUserPrimaryAvatar(avatar_id) {
+    return UserApiClient.setUserPrimaryAvatar(avatar_id);
   }
 
 }