@selfcommunity/api-services 0.1.28-alpha.3 → 0.1.28

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

@@ -16,360 +16,407 @@ export class UserApiClient {
     /**
      * This endpoint retrieves the list of all users
      * @param params
+     * @param config
      */
-    static getAllUsers(params) {
+    static getAllUsers(params, config) {
         const p = new URLSearchParams(params);
-        return apiRequest(`${Endpoints.UserList.url({})}?${p.toString()}`, Endpoints.UserList.method);
+        return apiRequest(Object.assign(Object.assign({}, config), { url: `${Endpoints.UserList.url({})}?${p.toString()}`, method: Endpoints.UserList.method }));
     }
     /**
      * This endpoint retrieves the list of all users hidden by the authenticated user
      * @param params
+     * @param config
      */
-    static getHiddenUsers(params) {
+    static getHiddenUsers(params, config) {
         const p = new URLSearchParams(params);
-        return apiRequest(`${Endpoints.ListHiddenUsers.url({})}?${p.toString()}`, Endpoints.ListHiddenUsers.method);
+        return apiRequest(Object.assign(Object.assign({}, config), { url: `${Endpoints.ListHiddenUsers.url({})}?${p.toString()}`, method: Endpoints.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
+     * @param config
      */
-    static userAutocomplete(params) {
+    static userAutocomplete(params, config) {
         const p = new URLSearchParams(params);
-        return apiRequest(`${Endpoints.UserAutocomplete.url({})}?${p.toString()}`, Endpoints.UserAutocomplete.method);
+        return apiRequest(Object.assign(Object.assign({}, config), { url: `${Endpoints.UserAutocomplete.url({})}?${p.toString()}`, method: Endpoints.UserAutocomplete.method }));
     }
     /**
      * This endpoint performs users search.
      * @param params
+     * @param config
      */
-    static userSearch(params) {
+    static userSearch(params, config) {
         const p = new URLSearchParams(params);
-        return apiRequest(`${Endpoints.UserSearch.url({})}?${p.toString()}`, Endpoints.UserSearch.method);
+        return apiRequest(Object.assign(Object.assign({}, config), { url: `${Endpoints.UserSearch.url({})}?${p.toString()}`, method: Endpoints.UserSearch.method }));
     }
     /**
      * This endpoint retrieves a specific user's profile identified by ID.
      * @param id
+     * @param config
      */
-    static getSpecificUser(id) {
-        return apiRequest(Endpoints.User.url({ id }), Endpoints.User.method);
+    static getSpecificUser(id, config) {
+        return apiRequest(Object.assign(Object.assign({}, config), { url: Endpoints.User.url({ id }), method: Endpoints.User.method }));
     }
     /**
-     * This endpoint retrieves the counters of a specific user identified by Id.
+     * This endpoint retrieves the counters of a specific user identified by ID.
      * @param id
+     * @param config
      */
-    static getUserCounters(id) {
-        return apiRequest(Endpoints.UserCounters.url({ id }), Endpoints.UserCounters.method);
+    static getUserCounters(id, config) {
+        return apiRequest(Object.assign(Object.assign({}, config), { url: Endpoints.UserCounters.url({ id }), method: Endpoints.UserCounters.method }));
     }
     /**
      * This endpoint updates the profile of a user identified by ID. A user can only update their personal data.
-     * If the request will update the avatar or the cover the 'Content-Type' request header must be set as 'multipart/form-data', otherwise it can be 'application/x-www-form-urlencoded'.
+     * If the request is willing to update the avatar or the cover the 'Content-Type' request header must be set as 'multipart/form-data', otherwise it can be 'application/x-www-form-urlencoded'.
      * @param id
      * @param data
+     * @param config
      */
-    static userUpdate(id, data) {
-        return apiRequest(Endpoints.UserUpdate.url({ id }), Endpoints.UserUpdate.method, data);
+    static userUpdate(id, data, config) {
+        return apiRequest(Object.assign(Object.assign({}, config), { url: Endpoints.UserUpdate.url({ id }), method: Endpoints.UserUpdate.method, data: data }));
     }
     /**
      * This endpoint patches a specific user identified by {id}
      * @param id
      * @param data
+     * @param config
      */
-    static userPatch(id, data) {
-        return apiRequest(Endpoints.UserPatch.url({ id }), Endpoints.UserPatch.method, data);
+    static userPatch(id, data, config) {
+        return apiRequest(Object.assign(Object.assign({}, config), { url: Endpoints.UserPatch.url({ id }), method: Endpoints.UserPatch.method, data: data }));
     }
     /**
      * This endpoint deletes a specific user identified by {id}
      * @param id
      * @param hard
+     * @param config
      */
-    static userDelete(id, hard) {
-        return apiRequest(`${Endpoints.UserDelete.url({ id })}?${hard.toString()}`, Endpoints.UserDelete.method);
+    static userDelete(id, hard, config) {
+        return apiRequest(Object.assign(Object.assign({}, config), { url: `${Endpoints.UserDelete.url({ id })}?${hard.toString()}`, method: Endpoints.UserDelete.method }));
     }
     /**
      * This endpoint changes the email of the authenticated user.
      * @param id
      * @param new_email
      * @param confirm
+     * @param config
      */
-    static changeUserMail(id, new_email, confirm) {
-        return apiRequest(Endpoints.ChangeUserMail.url({ id }), Endpoints.ChangeUserMail.method, {
-            new_email: new_email,
-            confirm: confirm
-        });
+    static changeUserMail(id, new_email, confirm, config) {
+        return apiRequest(Object.assign(Object.assign({}, config), { url: Endpoints.ChangeUserMail.url({ id }), method: Endpoints.ChangeUserMail.method, data: {
+                new_email: new_email,
+                confirm: confirm
+            } }));
     }
     /**
      * This endpoint confirms email change.
      * @param id
      * @param new_email
      * @param validation_code
+     * @param config
      */
-    static confirmChangeUserMail(id, new_email, validation_code) {
-        return apiRequest(Endpoints.ConfirmUserChangeMail.url({ id }), Endpoints.ConfirmUserChangeMail.method, {
-            new_email: new_email,
-            validation_code: validation_code
-        });
+    static confirmChangeUserMail(id, new_email, validation_code, config) {
+        return apiRequest(Object.assign(Object.assign({}, config), { url: Endpoints.ConfirmUserChangeMail.url({ id }), method: Endpoints.ConfirmUserChangeMail.method, data: {
+                new_email: new_email,
+                validation_code: validation_code
+            } }));
     }
     /**
      * This endpoint changes the password of the authenticated user.
      * @param id
      * @param password
      * @param new_password
+     * @param config
      */
-    static changeUserPassword(id, password, new_password) {
-        return apiRequest(Endpoints.ChangeUserPassword.url({ id }), Endpoints.ChangeUserPassword.method, {
-            password: password,
-            new_password: new_password
-        });
+    static changeUserPassword(id, password, new_password, config) {
+        return apiRequest(Object.assign(Object.assign({}, config), { url: Endpoints.ChangeUserPassword.url({ id }), method: Endpoints.ChangeUserPassword.method, data: {
+                password: password,
+                new_password: new_password
+            } }));
     }
     /**
      * This endpoint retrieves all current user's settings for the authenticated user.
      * @param id
+     * @param config
      */
-    static userSettings(id) {
-        return apiRequest(Endpoints.UserSettings.url({ id }), Endpoints.UserSettings.method);
+    static userSettings(id, config) {
+        return apiRequest(Object.assign(Object.assign({}, config), { url: Endpoints.UserSettings.url({ id }), method: Endpoints.UserSettings.method }));
     }
     /**
      * This endpoint changes the user settings for the authenticated user.
      * @param id
      * @param data
+     * @param config
      */
-    static userSettingsPatch(id, data) {
-        return apiRequest(Endpoints.UserSettingsPatch.url({ id }), Endpoints.UserSettingsPatch.method, data !== null && data !== void 0 ? data : null);
+    static userSettingsPatch(id, data, config) {
+        return apiRequest(Object.assign(Object.assign({}, config), { url: Endpoints.UserSettingsPatch.url({ id }), method: Endpoints.UserSettingsPatch.method, data: data !== null && data !== void 0 ? data : null }));
     }
     /**
      * This endpoint returns the user identified by the authentication token.
+     * @param config
      */
-    static getCurrentUser() {
-        return apiRequest(Endpoints.Me.url(), Endpoints.Me.method);
+    static getCurrentUser(config) {
+        return apiRequest(Object.assign(Object.assign({}, config), { url: Endpoints.Me.url(), method: Endpoints.Me.method }));
     }
     /**
      * This endpoint returns the url to the user's current avatar.
+     * @param config
      */
-    static getCurrentUserAvatar() {
-        return apiRequest(Endpoints.MyAvatar.url({}), Endpoints.MyAvatar.method);
+    static getCurrentUserAvatar(config) {
+        return apiRequest(Object.assign(Object.assign({}, config), { url: Endpoints.MyAvatar.url({}), method: Endpoints.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.
+     * This endpoint returns a list of permissions for the user identified by the authentication token. Some permissions in the list depend on global community settings.
+     * @param config
      */
-    static getCurrentUserPermission() {
-        return apiRequest(Endpoints.Permission.url({}), Endpoints.Permission.method);
+    static getCurrentUserPermission(config) {
+        return apiRequest(Object.assign(Object.assign({}, config), { url: Endpoints.Permission.url({}), method: Endpoints.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.
+     * @param config
      */
-    static getCurrentUserPlatform() {
-        return apiRequest(Endpoints.Platform.url({}), Endpoints.Platform.method);
+    static getCurrentUserPlatform(config) {
+        return apiRequest(Object.assign(Object.assign({}, config), { url: Endpoints.Platform.url({}), method: Endpoints.Platform.method }));
     }
     /**
      * This endpoint gets the list of categories followed by the user.
      * @param id
      * @param mutual
+     * @param config
      */
-    static getUserFollowedCategories(id, mutual) {
-        return apiRequest(Endpoints.FollowedCategories.url({ id, mutual }), Endpoints.FollowedCategories.method);
+    static getUserFollowedCategories(id, mutual, config) {
+        return apiRequest(Object.assign(Object.assign({}, config), { url: Endpoints.FollowedCategories.url({ id, mutual }), method: Endpoints.FollowedCategories.method }));
     }
     /**
      * This endpoint retrieves the list of posts of the user identified by {id}
      * @param id
+     * @param config
      */
-    static getUserFeed(id) {
-        return apiRequest(Endpoints.UserFeed.url({ id }), Endpoints.UserFeed.method);
+    static getUserFeed(id, config) {
+        return apiRequest(Object.assign(Object.assign({}, config), { url: Endpoints.UserFeed.url({ id }), method: Endpoints.UserFeed.method }));
     }
     /**
      * This endpoint retrieves the list of followers of a specific user identified by {id}
      * @param id
      * @param mutual
+     * @param config
      */
-    static getUserFollowers(id, mutual) {
-        return apiRequest(Endpoints.UserFollowers.url({ id, mutual }), Endpoints.UserFollowers.method);
+    static getUserFollowers(id, mutual, config) {
+        return apiRequest(Object.assign(Object.assign({}, config), { url: Endpoints.UserFollowers.url({ id, mutual }), method: Endpoints.UserFollowers.method }));
     }
     /**
      * This endpoint retrieves the list of following of a specific user identified by {id}.
      * @param id
      * @param mutual
+     * @param config
      */
-    static getUserFollowed(id, mutual) {
-        return apiRequest(Endpoints.UsersFollowed.url({ id, mutual }), Endpoints.UsersFollowed.method);
+    static getUserFollowed(id, mutual, config) {
+        return apiRequest(Object.assign(Object.assign({}, config), { url: Endpoints.UsersFollowed.url({ id, mutual }), method: Endpoints.UsersFollowed.method }));
     }
     /**
      * This endpoint allows a user to follow another user identified by {id}
      * @param id
+     * @param config
      */
-    static followUser(id) {
-        return apiRequest(Endpoints.FollowUser.url({ id }), Endpoints.FollowUser.method);
+    static followUser(id, config) {
+        return apiRequest(Object.assign(Object.assign({}, config), { url: Endpoints.FollowUser.url({ id }), method: Endpoints.FollowUser.method }));
     }
     /**
      * This endpoint returns is_followed = true if the user (identified in path) is followed by me.
      * @param id
+     * @param config
      */
-    static checkUserFollowed(id) {
-        return apiRequest(Endpoints.CheckUserFollowed.url({ id }), Endpoints.CheckUserFollowed.method);
+    static checkUserFollowed(id, config) {
+        return apiRequest(Object.assign(Object.assign({}, config), { url: Endpoints.CheckUserFollowed.url({ id }), method: Endpoints.CheckUserFollowed.method }));
     }
     /**
      * This endpoint returns is_follower = true if the user (identified in path) follow me
      * @param id
+     * @param config
      */
-    static checkUserFollower(id) {
-        return apiRequest(Endpoints.CheckUserFollower.url({ id }), Endpoints.CheckUserFollower.method);
+    static checkUserFollower(id, config) {
+        return apiRequest(Object.assign(Object.assign({}, config), { url: Endpoints.CheckUserFollower.url({ id }), method: Endpoints.CheckUserFollower.method }));
     }
     /**
      * This endpoint retrieves the list of connections of a specific user identified by ID.
      * @param id
      * @param mutual
+     * @param config
      */
-    static getUserConnections(id, mutual) {
-        return apiRequest(`${Endpoints.UserConnections.url({ id })}?${mutual.toString()}`, Endpoints.UserConnections.method);
+    static getUserConnections(id, mutual, config) {
+        return apiRequest(Object.assign(Object.assign({}, config), { url: `${Endpoints.UserConnections.url({ id })}?${mutual.toString()}`, method: Endpoints.UserConnections.method }));
     }
     /**
      * This endpoint returns is_connection = true if the user (identified in path) is connected with me.
      * @param id
+     * @param config
      */
-    static checkUserConnections(id) {
-        return apiRequest(Endpoints.UserCheckConnection.url({ id }), Endpoints.UserCheckConnection.method);
+    static checkUserConnections(id, config) {
+        return apiRequest(Object.assign(Object.assign({}, config), { url: Endpoints.UserCheckConnection.url({ id }), method: Endpoints.UserCheckConnection.method }));
     }
     /**
      * This endpoint retrieves the list of connection requests received by a specific user identified by ID.
      * @param id
+     * @param config
      */
-    static getUserConnectionRequests(id) {
-        return apiRequest(Endpoints.UserConnectionRequests.url({ id }), Endpoints.UserConnectionRequests.method);
+    static getUserConnectionRequests(id, config) {
+        return apiRequest(Object.assign(Object.assign({}, config), { url: Endpoints.UserConnectionRequests.url({ id }), method: Endpoints.UserConnectionRequests.method }));
     }
     /**
      * This endpoint retrieves a specific user's list of connection requests sent by user.
      * @param id
+     * @param config
      */
-    static getUserRequestConnectionsSent(id) {
-        return apiRequest(Endpoints.UserRequestConnectionsSent.url({ id }), Endpoints.UserRequestConnectionsSent.method);
+    static getUserRequestConnectionsSent(id, config) {
+        return apiRequest(Object.assign(Object.assign({}, config), { url: Endpoints.UserRequestConnectionsSent.url({ id }), method: Endpoints.UserRequestConnectionsSent.method }));
     }
     /**
      * This endpoint accepts a request connection of the user identified by {id}
      * @param id
+     * @param config
      */
-    static userAcceptRequestConnection(id) {
-        return apiRequest(Endpoints.UserAcceptRequestConnection.url({ id }), Endpoints.UserAcceptRequestConnection.method);
+    static userAcceptRequestConnection(id, config) {
+        return apiRequest(Object.assign(Object.assign({}, config), { url: Endpoints.UserAcceptRequestConnection.url({ id }), method: Endpoints.UserAcceptRequestConnection.method }));
     }
     /**
      * This endpoint requests a connection to the user identified by {id}
      * @param id
+     * @param config
      */
-    static userRequestConnection(id) {
-        return apiRequest(Endpoints.UserRequestConnection.url({ id }), Endpoints.UserRequestConnection.method);
+    static userRequestConnection(id, config) {
+        return apiRequest(Object.assign(Object.assign({}, config), { url: Endpoints.UserRequestConnection.url({ id }), method: Endpoints.UserRequestConnection.method }));
     }
     /**
      * This endpoint removes connection with the user identified by {id}
      * @param id
+     * @param config
      */
-    static userRemoveConnection(id) {
-        return apiRequest(Endpoints.UserRemoveConnection.url({ id }), Endpoints.UserRemoveConnection.method);
+    static userRemoveConnection(id, config) {
+        return apiRequest(Object.assign(Object.assign({}, config), { url: Endpoints.UserRemoveConnection.url({ id }), method: Endpoints.UserRemoveConnection.method }));
     }
     /**
      * This endpoint cancels reject connection to a user identified by {id}
      * @param id
+     * @param config
      */
-    static userCancelRejectConnectionRequest(id) {
-        return apiRequest(Endpoints.UserCancelRejectConnectionRequest.url({ id }), Endpoints.UserCancelRejectConnectionRequest.method);
+    static userCancelRejectConnectionRequest(id, config) {
+        return apiRequest(Object.assign(Object.assign({}, config), { url: Endpoints.UserCancelRejectConnectionRequest.url({ id }), method: Endpoints.UserCancelRejectConnectionRequest.method }));
     }
     /**
      * This endpoint cancels a request connection for a user.
      * @param id
+     * @param config
      */
-    static userCancelRequestConnection(id) {
-        return apiRequest(Endpoints.UserCancelRequestConnection.url({ id }), Endpoints.UserCancelRequestConnection.method);
+    static userCancelRequestConnection(id, config) {
+        return apiRequest(Object.assign(Object.assign({}, config), { url: Endpoints.UserCancelRequestConnection.url({ id }), method: Endpoints.UserCancelRequestConnection.method }));
     }
     /**
      * This endpoint rejects a connection request sent from user identified by {id}
      * @param id
+     * @param config
      */
-    static userRejectConnectionRequest(id) {
-        return apiRequest(Endpoints.UserRejectConnectionRequest.url({ id }), Endpoints.UserRejectConnectionRequest.method);
+    static userRejectConnectionRequest(id, config) {
+        return apiRequest(Object.assign(Object.assign({}, config), { url: Endpoints.UserRejectConnectionRequest.url({ id }), method: Endpoints.UserRejectConnectionRequest.method }));
     }
     /**
      * This endpoint marks seen a connection request of user identified by {id} for the authenticated user.
      * @param id
+     * @param config
      */
-    static userMarkSeenConnectionRequest(id) {
-        return apiRequest(Endpoints.UserMarkSeenConnectionRequest.url({ id }), Endpoints.UserMarkSeenConnectionRequest.method);
+    static userMarkSeenConnectionRequest(id, config) {
+        return apiRequest(Object.assign(Object.assign({}, config), { url: Endpoints.UserMarkSeenConnectionRequest.url({ id }), method: Endpoints.UserMarkSeenConnectionRequest.method }));
     }
     /**
      * This endpoint shows/hides a user (and its posts) identified by {id} for the authenticated user.
      * @param id
+     * @param config
      */
-    static showHideUser(id) {
-        return apiRequest(Endpoints.UserShowHide.url({ id }), Endpoints.UserShowHide.method);
+    static showHideUser(id, config) {
+        return apiRequest(Object.assign(Object.assign({}, config), { url: Endpoints.UserShowHide.url({ id }), method: Endpoints.UserShowHide.method }));
     }
     /**
      * This endpoint returns true if the user (identified in path) is hidden by the authenticated user.
      * @param id
+     * @param config
      */
-    static checkUserHidden(id) {
-        return apiRequest(Endpoints.CheckUserHidden.url({ id }), Endpoints.CheckUserHidden.method);
+    static checkUserHidden(id, config) {
+        return apiRequest(Object.assign(Object.assign({}, config), { url: Endpoints.CheckUserHidden.url({ id }), method: Endpoints.CheckUserHidden.method }));
     }
     /**
      * This endpoint returns true if the user (identified in path) has hidden by the authenticated user.
      * @param id
+     * @param config
      */
-    static checkUserHiddenBy(id) {
-        return apiRequest(Endpoints.CheckUserHiddenBy.url({ id }), Endpoints.CheckUserHiddenBy.method);
+    static checkUserHiddenBy(id, config) {
+        return apiRequest(Object.assign(Object.assign({}, config), { url: Endpoints.CheckUserHiddenBy.url({ id }), method: Endpoints.CheckUserHiddenBy.method }));
     }
     /**
      * This endpoint returns user's loyalty points.
      * @param id
+     * @param config
      */
-    static getUserLoyaltyPoints(id) {
-        return apiRequest(Endpoints.GetUserLoyaltyPoints.url({ id }), Endpoints.GetUserLoyaltyPoints.method);
+    static getUserLoyaltyPoints(id, config) {
+        return apiRequest(Object.assign(Object.assign({}, config), { url: Endpoints.GetUserLoyaltyPoints.url({ id }), method: Endpoints.GetUserLoyaltyPoints.method }));
     }
     /**
      * This endpoint lists the connection/follow statuses of the logged user starting from a users array.
      * @param users
+     * @param config
      */
-    static getUserConnectionStatuses(users) {
-        return apiRequest(Endpoints.UserConnectionStatuses.url({}), Endpoints.UserConnectionStatuses.method, { users: users });
+    static getUserConnectionStatuses(users, config) {
+        return apiRequest(Object.assign(Object.assign({}, config), { url: Endpoints.UserConnectionStatuses.url({}), method: Endpoints.UserConnectionStatuses.method, data: { users: users } }));
     }
     /**
      * This endpoint returns user's tags to address a contribution.
+     * @param config
      */
-    static userTagToAddressContribution() {
-        return apiRequest(Endpoints.UserTagToAddressContribution.url({}), Endpoints.UserTagToAddressContribution.method);
+    static userTagToAddressContribution(config) {
+        return apiRequest(Object.assign(Object.assign({}, config), { url: Endpoints.UserTagToAddressContribution.url({}), method: Endpoints.UserTagToAddressContribution.method }));
     }
     /**
      * This endpoint checks an email token.
      * @param email_token
+     * @param config
      */
-    static checkUserEmailToken(email_token) {
+    static checkUserEmailToken(email_token, config) {
         const p = new URLSearchParams({ email_token: email_token });
-        return apiRequest(`${Endpoints.CheckEmailToken.url({})}?${p.toString()}`, Endpoints.CheckEmailToken.method);
+        return apiRequest(Object.assign(Object.assign({}, config), { url: `${Endpoints.CheckEmailToken.url({})}?${p.toString()}`, method: Endpoints.CheckEmailToken.method }));
     }
     /**
      * This endpoint adds an avatar to my avatars.
      * @param avatar
+     * @param config
      */
-    static addUserAvatar(avatar) {
-        return apiRequest(Endpoints.AddAvatar.url({}), Endpoints.AddAvatar.method, { avatar: avatar });
+    static addUserAvatar(avatar, config) {
+        return apiRequest(Object.assign(Object.assign({}, config), { url: Endpoints.AddAvatar.url({}), method: Endpoints.AddAvatar.method, data: { avatar: avatar } }));
     }
     /**
      * This endpoint retrieves all user avatars.
+     * @param config
      */
-    static getUserAvatars() {
-        return apiRequest(Endpoints.GetAvatars.url({}), Endpoints.GetAvatars.method);
+    static getUserAvatars(config) {
+        return apiRequest(Object.assign(Object.assign({}, config), { url: Endpoints.GetAvatars.url({}), method: Endpoints.GetAvatars.method }));
     }
     /**
      * This endpoint removes/deletes an avatar from the authenticated user avatars.
      * @param avatar_id
+     * @param config
      */
-    static removeUserAvatar(avatar_id) {
-        return apiRequest(Endpoints.RemoveAvatar.url({}), Endpoints.RemoveAvatar.method, { avatar_id: avatar_id });
+    static removeUserAvatar(avatar_id, config) {
+        return apiRequest(Object.assign(Object.assign({}, config), { url: Endpoints.RemoveAvatar.url({}), method: Endpoints.RemoveAvatar.method, data: { avatar_id: avatar_id } }));
     }
     /**
      * This endpoint sets the primary avatar for the authenticated user.
      * @param avatar_id
+     * @param config
      */
-    static setUserPrimaryAvatar(avatar_id) {
-        return apiRequest(Endpoints.SetPrimaryAvatar.url({}), Endpoints.SetPrimaryAvatar.method, { avatar_id: avatar_id });
+    static setUserPrimaryAvatar(avatar_id, config) {
+        return apiRequest(Object.assign(Object.assign({}, config), { url: Endpoints.SetPrimaryAvatar.url({}), method: Endpoints.SetPrimaryAvatar.method, data: { avatar_id: avatar_id } }));
     }
 }
 /**
  *
- :::tipUser service can be used in the following ways:
+ :::tipUser service can be used in the following way:
 
  ```jsx
  1. Import the service from our library:
@@ -391,242 +438,253 @@ export class UserApiClient {
        return await UserService.getSpecificUser(userId);
       }
  ```
+
+ ```jsx
+ If you need to customize the request, you can add optional config params (`AxiosRequestConfig` type).
+
+ Ex: If the async function `userUpdate`  is willing to update the avatar or the cover the 'Content-Type' request header must be set as 'multipart/form-data'.
+
+ async getSpecificUser(userId, data, config) {
+ const headers = {headers: {'Content-Type': 'multipart/form-data'}}
+       return await UserService.getSpecificUser(userId, {avatar: avatar}, headers);
+      }
+ ```
  :::
  */
 export default class UserService {
-    static getAllUsers(params) {
+    static getAllUsers(params, config) {
         return __awaiter(this, void 0, void 0, function* () {
-            return UserApiClient.getAllUsers(params);
+            return UserApiClient.getAllUsers(params, config);
         });
     }
-    static getHiddenUsers(params) {
+    static getHiddenUsers(params, config) {
         return __awaiter(this, void 0, void 0, function* () {
-            return UserApiClient.getHiddenUsers(params);
+            return UserApiClient.getHiddenUsers(params, config);
         });
     }
-    static userAutocomplete(params) {
+    static userAutocomplete(params, config) {
         return __awaiter(this, void 0, void 0, function* () {
-            return UserApiClient.userAutocomplete(params);
+            return UserApiClient.userAutocomplete(params, config);
         });
     }
-    static userSearch(params) {
+    static userSearch(params, config) {
         return __awaiter(this, void 0, void 0, function* () {
-            return UserApiClient.userSearch(params);
+            return UserApiClient.userSearch(params, config);
         });
     }
-    static getSpecificUser(id) {
+    static getSpecificUser(id, config) {
         return __awaiter(this, void 0, void 0, function* () {
-            return UserApiClient.getSpecificUser(id);
+            return UserApiClient.getSpecificUser(id, config);
         });
     }
-    static getUserCounters(id) {
+    static getUserCounters(id, config) {
         return __awaiter(this, void 0, void 0, function* () {
-            return UserApiClient.getUserCounters(id);
+            return UserApiClient.getUserCounters(id, config);
         });
     }
-    static userUpdate(id, data) {
+    static userUpdate(id, data, config) {
         return __awaiter(this, void 0, void 0, function* () {
-            return UserApiClient.userUpdate(id, data);
+            return UserApiClient.userUpdate(id, data, config);
         });
     }
-    static userPatch(id, data) {
+    static userPatch(id, data, config) {
         return __awaiter(this, void 0, void 0, function* () {
-            return UserApiClient.userPatch(id, data);
+            return UserApiClient.userPatch(id, data, config);
         });
     }
-    static userDelete(id, hard) {
+    static userDelete(id, hard, config) {
         return __awaiter(this, void 0, void 0, function* () {
-            return UserApiClient.userDelete(id, hard);
+            return UserApiClient.userDelete(id, hard, config);
         });
     }
-    static changeUserMail(id, new_email, confirm) {
+    static changeUserMail(id, new_email, confirm, config) {
         return __awaiter(this, void 0, void 0, function* () {
-            return UserApiClient.changeUserMail(id, new_email, confirm);
+            return UserApiClient.changeUserMail(id, new_email, confirm, config);
         });
     }
-    static confirmChangeUserMail(id, new_email, validation_code) {
+    static confirmChangeUserMail(id, new_email, validation_code, config) {
         return __awaiter(this, void 0, void 0, function* () {
-            return UserApiClient.confirmChangeUserMail(id, new_email, validation_code);
+            return UserApiClient.confirmChangeUserMail(id, new_email, validation_code, config);
         });
     }
-    static changeUserPassword(id, password, new_password) {
+    static changeUserPassword(id, password, new_password, config) {
         return __awaiter(this, void 0, void 0, function* () {
-            return UserApiClient.changeUserPassword(id, password, new_password);
+            return UserApiClient.changeUserPassword(id, password, new_password, config);
         });
     }
-    static userSettings(id) {
+    static userSettings(id, config) {
         return __awaiter(this, void 0, void 0, function* () {
-            return UserApiClient.userSettings(id);
+            return UserApiClient.userSettings(id, config);
         });
     }
-    static userSettingsPatch(id, data) {
+    static userSettingsPatch(id, data, config) {
         return __awaiter(this, void 0, void 0, function* () {
-            return UserApiClient.userSettingsPatch(id, data);
+            return UserApiClient.userSettingsPatch(id, data, config);
         });
     }
-    static getCurrentUser() {
+    static getCurrentUser(config) {
         return __awaiter(this, void 0, void 0, function* () {
-            return UserApiClient.getCurrentUser();
+            return UserApiClient.getCurrentUser(config);
         });
     }
-    static getCurrentUserAvatar() {
+    static getCurrentUserAvatar(config) {
         return __awaiter(this, void 0, void 0, function* () {
-            return UserApiClient.getCurrentUserAvatar();
+            return UserApiClient.getCurrentUserAvatar(config);
         });
     }
-    static getCurrentUserPermission() {
+    static getCurrentUserPermission(config) {
         return __awaiter(this, void 0, void 0, function* () {
-            return UserApiClient.getCurrentUserPermission();
+            return UserApiClient.getCurrentUserPermission(config);
         });
     }
-    static getCurrentUserPlatform() {
+    static getCurrentUserPlatform(config) {
         return __awaiter(this, void 0, void 0, function* () {
-            return UserApiClient.getCurrentUserPlatform();
+            return UserApiClient.getCurrentUserPlatform(config);
         });
     }
-    static getUserFollowedCategories(id, mutual) {
+    static getUserFollowedCategories(id, mutual, config) {
         return __awaiter(this, void 0, void 0, function* () {
-            return UserApiClient.getUserFollowedCategories(id, mutual);
+            return UserApiClient.getUserFollowedCategories(id, mutual, config);
         });
     }
-    static getUserFeed(id) {
+    static getUserFeed(id, config) {
         return __awaiter(this, void 0, void 0, function* () {
-            return UserApiClient.getUserFeed(id);
+            return UserApiClient.getUserFeed(id, config);
         });
     }
-    static getUserFollowers(id, mutual) {
+    static getUserFollowers(id, mutual, config) {
         return __awaiter(this, void 0, void 0, function* () {
-            return UserApiClient.getUserFollowers(id, mutual);
+            return UserApiClient.getUserFollowers(id, mutual, config);
         });
     }
-    static getUserFollowed(id, mutual) {
+    static getUserFollowed(id, mutual, config) {
         return __awaiter(this, void 0, void 0, function* () {
-            return UserApiClient.getUserFollowed(id, mutual);
+            return UserApiClient.getUserFollowed(id, mutual, config);
         });
     }
-    static followUser(id) {
+    static followUser(id, config) {
         return __awaiter(this, void 0, void 0, function* () {
-            return UserApiClient.followUser(id);
+            return UserApiClient.followUser(id, config);
         });
     }
-    static checkUserFollowed(id) {
+    static checkUserFollowed(id, config) {
         return __awaiter(this, void 0, void 0, function* () {
-            return UserApiClient.checkUserFollowed(id);
+            return UserApiClient.checkUserFollowed(id, config);
         });
     }
-    static checkUserFollower(id) {
+    static checkUserFollower(id, config) {
         return __awaiter(this, void 0, void 0, function* () {
-            return UserApiClient.checkUserFollower(id);
+            return UserApiClient.checkUserFollower(id, config);
         });
     }
-    static getUserConnections(id, mutual) {
+    static getUserConnections(id, mutual, config) {
         return __awaiter(this, void 0, void 0, function* () {
-            return UserApiClient.getUserConnections(id, mutual);
+            return UserApiClient.getUserConnections(id, mutual, config);
         });
     }
-    static checkUserConnections(id) {
+    static checkUserConnections(id, config) {
         return __awaiter(this, void 0, void 0, function* () {
-            return UserApiClient.checkUserConnections(id);
+            return UserApiClient.checkUserConnections(id, config);
         });
     }
-    static getUserConnectionRequests(id) {
+    static getUserConnectionRequests(id, config) {
         return __awaiter(this, void 0, void 0, function* () {
-            return UserApiClient.getUserConnectionRequests(id);
+            return UserApiClient.getUserConnectionRequests(id, config);
         });
     }
-    static getUserRequestConnectionsSent(id) {
+    static getUserRequestConnectionsSent(id, config) {
         return __awaiter(this, void 0, void 0, function* () {
-            return UserApiClient.getUserRequestConnectionsSent(id);
+            return UserApiClient.getUserRequestConnectionsSent(id, config);
         });
     }
-    static userAcceptRequestConnection(id) {
+    static userAcceptRequestConnection(id, config) {
         return __awaiter(this, void 0, void 0, function* () {
-            return UserApiClient.userAcceptRequestConnection(id);
+            return UserApiClient.userAcceptRequestConnection(id, config);
         });
     }
-    static userRequestConnection(id) {
+    static userRequestConnection(id, config) {
         return __awaiter(this, void 0, void 0, function* () {
-            return UserApiClient.userRequestConnection(id);
+            return UserApiClient.userRequestConnection(id, config);
         });
     }
-    static userRemoveConnection(id) {
+    static userRemoveConnection(id, config) {
         return __awaiter(this, void 0, void 0, function* () {
-            return UserApiClient.userRemoveConnection(id);
+            return UserApiClient.userRemoveConnection(id, config);
         });
     }
-    static userCancelRejectConnectionRequest(id) {
+    static userCancelRejectConnectionRequest(id, config) {
         return __awaiter(this, void 0, void 0, function* () {
-            return UserApiClient.userCancelRejectConnectionRequest(id);
+            return UserApiClient.userCancelRejectConnectionRequest(id, config);
         });
     }
-    static userCancelRequestConnection(id) {
+    static userCancelRequestConnection(id, config) {
         return __awaiter(this, void 0, void 0, function* () {
-            return UserApiClient.userCancelRequestConnection(id);
+            return UserApiClient.userCancelRequestConnection(id, config);
         });
     }
-    static userRejectConnectionRequest(id) {
+    static userRejectConnectionRequest(id, config) {
         return __awaiter(this, void 0, void 0, function* () {
-            return UserApiClient.userRejectConnectionRequest(id);
+            return UserApiClient.userRejectConnectionRequest(id, config);
         });
     }
-    static userMarkSeenConnectionRequest(id) {
+    static userMarkSeenConnectionRequest(id, config) {
         return __awaiter(this, void 0, void 0, function* () {
-            return UserApiClient.userMarkSeenConnectionRequest(id);
+            return UserApiClient.userMarkSeenConnectionRequest(id, config);
         });
     }
-    static showHideUser(id) {
+    static showHideUser(id, config) {
         return __awaiter(this, void 0, void 0, function* () {
-            return UserApiClient.showHideUser(id);
+            return UserApiClient.showHideUser(id, config);
         });
     }
-    static checkUserHidden(id) {
+    static checkUserHidden(id, config) {
         return __awaiter(this, void 0, void 0, function* () {
-            return UserApiClient.checkUserHidden(id);
+            return UserApiClient.checkUserHidden(id, config);
         });
     }
-    static checkUserHiddenBy(id) {
+    static checkUserHiddenBy(id, config) {
         return __awaiter(this, void 0, void 0, function* () {
-            return UserApiClient.checkUserHiddenBy(id);
+            return UserApiClient.checkUserHiddenBy(id, config);
         });
     }
-    static getUserLoyaltyPoints(id) {
+    static getUserLoyaltyPoints(id, config) {
         return __awaiter(this, void 0, void 0, function* () {
-            return UserApiClient.getUserLoyaltyPoints(id);
+            return UserApiClient.getUserLoyaltyPoints(id, config);
         });
     }
-    static getUserConnectionStatuses(users) {
+    static getUserConnectionStatuses(users, config) {
         return __awaiter(this, void 0, void 0, function* () {
-            return UserApiClient.getUserConnectionStatuses(users);
+            return UserApiClient.getUserConnectionStatuses(users, config);
         });
     }
-    static userTagToAddressContribution() {
+    static userTagToAddressContribution(config) {
         return __awaiter(this, void 0, void 0, function* () {
-            return UserApiClient.userTagToAddressContribution();
+            return UserApiClient.userTagToAddressContribution(config);
         });
     }
-    static checkUserEmailToken(email_token) {
+    static checkUserEmailToken(email_token, config) {
         return __awaiter(this, void 0, void 0, function* () {
-            return UserApiClient.checkUserEmailToken(email_token);
+            return UserApiClient.checkUserEmailToken(email_token, config);
         });
     }
-    static addUserAvatar(avatar) {
+    static addUserAvatar(avatar, config) {
         return __awaiter(this, void 0, void 0, function* () {
-            return UserApiClient.addUserAvatar(avatar);
+            return UserApiClient.addUserAvatar(avatar, config);
         });
     }
-    static getUserAvatars() {
+    static getUserAvatars(config) {
         return __awaiter(this, void 0, void 0, function* () {
-            return UserApiClient.getUserAvatars();
+            return UserApiClient.getUserAvatars(config);
         });
     }
-    static removeUserAvatar(avatar_id) {
+    static removeUserAvatar(avatar_id, config) {
         return __awaiter(this, void 0, void 0, function* () {
-            return UserApiClient.removeUserAvatar(avatar_id);
+            return UserApiClient.removeUserAvatar(avatar_id, config);
         });
     }
-    static setUserPrimaryAvatar(avatar_id) {
+    static setUserPrimaryAvatar(avatar_id, config) {
         return __awaiter(this, void 0, void 0, function* () {
-            return UserApiClient.setUserPrimaryAvatar(avatar_id);
+            return UserApiClient.setUserPrimaryAvatar(avatar_id, config);
         });
     }
 }