@selfcommunity/api-services 0.1.4 → 0.1.5

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

@@ -27,6 +27,57 @@ class UserApiClient {
     });
   }
 
+  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);
+    });
+  }
+
+  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 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 getSpecificUser(id) {
     return _client.default.request({
       url: _Endpoints.default.User.url({
@@ -46,6 +97,177 @@ class UserApiClient {
     });
   }
 
+  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);
+    });
+  }
+
+  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 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 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 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 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 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 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);
+    });
+  }
+
+  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 getCurrentUser() {
     return _client.default.request({
       url: _Endpoints.default.Me.url(),
@@ -63,21 +285,785 @@ class UserApiClient {
     });
   }
 
-}
+  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);
+      }
 
-exports.UserApiClient = UserApiClient;
+      return Promise.resolve(res.data);
+    }).catch(error => {
+      console.log('Unable to retrieve user avatar.');
+      return Promise.reject(error);
+    });
+  }
 
-class UserService {
-  static async getAllUsers() {
-    return UserApiClient.getAllUsers();
+  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);
+    });
   }
 
-  static async getSpecificUser(id) {
-    return UserApiClient.getSpecificUser(id);
+  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);
+    });
   }
 
-  static async getCurrentUser() {
-    return UserApiClient.getCurrentUser();
+  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 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);
+    });
+  }
+
+  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 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 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);
+    });
+  }
+
+  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);
+    });
+  }
+
+  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);
+    });
+  }
+
+  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 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);
+    });
+  }
+
+  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);
+    });
+  }
+
+  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);
+    });
+  }
+
+  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);
+    });
+  }
+
+  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);
+    });
+  }
+
+  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);
+    });
+  }
+
+  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);
+    });
+  }
+
+  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);
+    });
+  }
+
+  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);
+    });
+  }
+
+  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);
+    });
+  }
+
+  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);
+    });
+  }
+
+  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);
+    });
+  }
+
+  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);
+    });
+  }
+
+  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);
+    });
+  }
+
+  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 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);
+    });
+  }
+
+  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);
+    });
+  }
+
+  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 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);
+    });
+  }
+
+  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 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);
+    });
+  }
+
+}
+
+exports.UserApiClient = UserApiClient;
+
+class UserService {
+  static async getAllUsers() {
+    return UserApiClient.getAllUsers();
+  }
+
+  static async getHiddenUsers() {
+    return UserApiClient.getHiddenUsers();
+  }
+
+  static async userAutocomplete() {
+    return UserApiClient.userAutocomplete();
+  }
+
+  static async userSearch() {
+    return UserApiClient.userSearch();
+  }
+
+  static async getSpecificUser(id) {
+    return UserApiClient.getSpecificUser(id);
+  }
+
+  static async getUserCounters(id) {
+    return UserApiClient.getUserCounters(id);
+  }
+
+  static async userUpdate(id) {
+    return UserApiClient.userUpdate(id);
+  }
+
+  static async userPatch(id) {
+    return UserApiClient.userPatch(id);
+  }
+
+  static async userDelete(id) {
+    return UserApiClient.userDelete(id);
+  }
+
+  static async changeUserMail(id) {
+    return UserApiClient.changeUserMail(id);
+  }
+
+  static async confirmChangeUserMail(id) {
+    return UserApiClient.confirmChangeUserMail(id);
+  }
+
+  static async changeUserPassword(id) {
+    return UserApiClient.changeUserPassword(id);
+  }
+
+  static async userSettings(id) {
+    return UserApiClient.userSettings(id);
+  }
+
+  static async userSettingsPatch(id) {
+    return UserApiClient.userSettingsPatch(id);
+  }
+
+  static async getCurrentUser() {
+    return UserApiClient.getCurrentUser();
+  }
+
+  static async getCurrentUserAvatar() {
+    return UserApiClient.getCurrentUserAvatar();
+  }
+
+  static async getCurrentUserPermission() {
+    return UserApiClient.getCurrentUserPermission();
+  }
+
+  static async getCurrentUserPlatform() {
+    return UserApiClient.getCurrentUserPlatform();
+  }
+
+  static async getUserFollowedCategories(id) {
+    return UserApiClient.getUserFollowedCategories(id);
+  }
+
+  static async getUserFeed(id) {
+    return UserApiClient.getUserFeed(id);
+  }
+
+  static async getUserFollowers(id) {
+    return UserApiClient.getUserFollowers(id);
+  }
+
+  static async getUserFollowed(id) {
+    return UserApiClient.getUserFollowed(id);
+  }
+
+  static async followUser(id) {
+    return UserApiClient.followUser(id);
+  }
+
+  static async checkUserFollowed(id) {
+    return UserApiClient.checkUserFollowed(id);
+  }
+
+  static async checkUserFollower(id) {
+    return UserApiClient.checkUserFollower(id);
+  }
+
+  static async getUserConnections(id) {
+    return UserApiClient.getUserConnections(id);
+  }
+
+  static async checkUserConnections(id) {
+    return UserApiClient.checkUserConnections(id);
+  }
+
+  static async getUserConnectionRequests(id) {
+    return UserApiClient.getUserConnectionRequests(id);
+  }
+
+  static async getUserRequestConnectionsSent(id) {
+    return UserApiClient.getUserRequestConnectionsSent(id);
+  }
+
+  static async userAcceptRequestConnection(id) {
+    return UserApiClient.userAcceptRequestConnection(id);
+  }
+
+  static async userRequestConnection(id) {
+    return UserApiClient.userRequestConnection(id);
+  }
+
+  static async userRemoveConnection(id) {
+    return UserApiClient.userRemoveConnection(id);
+  }
+
+  static async userCancelRejectConnectionRequest(id) {
+    return UserApiClient.userCancelRejectConnectionRequest(id);
+  }
+
+  static async userCancelRequestConnection(id) {
+    return UserApiClient.userCancelRequestConnection(id);
+  }
+
+  static async userRejectConnectionRequest(id) {
+    return UserApiClient.userRejectConnectionRequest(id);
+  }
+
+  static async userMarkSeenConnectionRequest(id) {
+    return UserApiClient.userMarkSeenConnectionRequest(id);
+  }
+
+  static async showHideUser(id) {
+    return UserApiClient.showHideUser(id);
+  }
+
+  static async checkUserHidden(id) {
+    return UserApiClient.checkUserHidden(id);
+  }
+
+  static async checkUserHiddenBy(id) {
+    return UserApiClient.checkUserHiddenBy(id);
+  }
+
+  static async getUserLoyaltyPoints(id) {
+    return UserApiClient.getUserLoyaltyPoints(id);
+  }
+
+  static async getUserConnectionStatuses() {
+    return UserApiClient.getUserConnectionStatuses();
+  }
+
+  static async userTagToAddressContribution() {
+    return UserApiClient.userTagToAddressContribution();
+  }
+
+  static async checkUserEmailToken() {
+    return UserApiClient.checkUserEmailToken();
+  }
+
+  static async addUserAvatar() {
+    return UserApiClient.addUserAvatar();
+  }
+
+  static async getUserAvatars() {
+    return UserApiClient.getUserAvatars();
+  }
+
+  static async removeUserAvatar() {
+    return UserApiClient.removeUserAvatar();
+  }
+
+  static async setUserPrimaryAvatar() {
+    return UserApiClient.setUserPrimaryAvatar();
   }
 
 }