@atlaskit/teams-client 4.0.0

package/dist/esm/services/directory-client/index.js

@@ -0,0 +1,234 @@
+import _typeof from "@babel/runtime/helpers/typeof";
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
+import _inherits from "@babel/runtime/helpers/inherits";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+import { DEFAULT_CONFIG } from '../constants';
+import { BaseGraphQlClient } from '../graphql-client';
+import { logException } from '../sentry/main';
+export var BROWSE_USER_SETTINGS_KEY = 'internal.browse-users-allowed';
+var buildTeamMembershipQuery = function buildTeamMembershipQuery(teamId, membershipState) {
+  return {
+    query: "query TeamMembership($teamId: String!, $membershipState: [TeamMembershipStatus]) {\n    TeamMembership: TeamMembership(teamId: $teamId, membershipStates: $membershipState) {\n      user: profile {\n        id,\n        fullName,\n        title,\n        avatarUrl,\n        timezone,\n        status\n      },\n      state:membershipStatus,\n      role,\n      membershipId {\n        teamId, memberId\n      }\n    }\n  }",
+    variables: {
+      teamId: teamId,
+      membershipState: membershipState
+    }
+  };
+};
+
+/**
+ * @type CloudUser
+ * @property {string} avatarUrl
+ * @property {string} id
+ * @property {string} fullName
+ * @property {string} title
+ */
+
+var buildUserQuery = function buildUserQuery(userId, cloudId) {
+  return {
+    query: "query CloudUser($userId: String!, $cloudId: String!) {\n    CloudUser(userId: $userId, cloudId: $cloudId) {\n      avatarUrl\n      id\n      fullName\n      title\n    }\n  }",
+    variables: {
+      userId: userId,
+      cloudId: cloudId
+    }
+  };
+};
+var delay = function delay(millis) {
+  return new Promise(function (resolve) {
+    setTimeout(resolve, millis);
+  });
+};
+export var DirectoryClient = /*#__PURE__*/function (_BaseGraphQlClient) {
+  function DirectoryClient(baseUrl, config) {
+    _classCallCheck(this, DirectoryClient);
+    return _callSuper(this, DirectoryClient, ["".concat(baseUrl, "/directory/graphql"), config]);
+  }
+  _inherits(DirectoryClient, _BaseGraphQlClient);
+  return _createClass(DirectoryClient, [{
+    key: "setBaseUrl",
+    value: function setBaseUrl(baseUrl) {
+      this.setServiceUrl("".concat(baseUrl, "/directory/graphql"));
+    }
+  }, {
+    key: "queryFeatureFlags",
+    value: function () {
+      var _queryFeatureFlags = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(
+      /**
+       * @private
+       * @deprecated don't need to pass param, value is taken from `this.getCloudId()` instead
+       */
+      cloudId, flags) {
+        var queryFeatureFlags, _yield$this$makeGraph, FeatureFlags;
+        return _regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              queryFeatureFlags = {
+                query: "query FeatureFlags($cloudId: String!, $flags: [String]!) {\n        FeatureFlags(cloudId: $cloudId, flags: $flags) {\n          flag\n          enabled\n        }\n      }",
+                variables: {
+                  cloudId: this.getCloudId(cloudId),
+                  flags: flags
+                }
+              };
+              _context.next = 3;
+              return this.makeGraphQLRequest(queryFeatureFlags, {
+                operationName: 'FeatureFlags'
+              });
+            case 3:
+              _yield$this$makeGraph = _context.sent;
+              FeatureFlags = _yield$this$makeGraph.FeatureFlags;
+              return _context.abrupt("return", FeatureFlags.map(function (_ref) {
+                var flag = _ref.flag,
+                  enabled = _ref.enabled;
+                return [flag, enabled];
+              }).reduce(function (acc, val) {
+                return acc[val[0]] = val[1], acc;
+              }, {}));
+            case 6:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this);
+      }));
+      function queryFeatureFlags(_x, _x2) {
+        return _queryFeatureFlags.apply(this, arguments);
+      }
+      return queryFeatureFlags;
+    }()
+  }, {
+    key: "canRetryError",
+    value: function canRetryError(pendingRetries, error) {
+      return pendingRetries > 0 && !!error && _typeof(error) === 'object' && 'category' in error && error.category === 'NotFound';
+    }
+
+    /**
+     * Get user information of all members of a team
+     * @param {string} teamId
+     * @returns {Promise}
+     * @private
+     * @deprecated use AGG instead
+     */
+  }, {
+    key: "queryTeamMemberships",
+    value: function queryTeamMemberships(teamId) {
+      var _this = this;
+      var membershipStatus = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ['FULL_MEMBER'];
+      // eslint-disable-next-line no-console
+      console.warn('Directory queryTeamMemberships is deprecated, use AGG instead');
+      var teamMembershipsQuery = buildTeamMembershipQuery(teamId, membershipStatus);
+      var _performRequest = /*#__PURE__*/function () {
+        var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+          var pendingRetries,
+            backoffMaxDelay,
+            _args2 = arguments;
+          return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+            while (1) switch (_context2.prev = _context2.next) {
+              case 0:
+                pendingRetries = _args2.length > 0 && _args2[0] !== undefined ? _args2[0] : 3;
+                backoffMaxDelay = _args2.length > 1 && _args2[1] !== undefined ? _args2[1] : 2000;
+                _context2.prev = 2;
+                _context2.next = 5;
+                return _this.makeGraphQLRequest(teamMembershipsQuery, {
+                  operationName: 'TeamMembership'
+                });
+              case 5:
+                return _context2.abrupt("return", _context2.sent);
+              case 8:
+                _context2.prev = 8;
+                _context2.t0 = _context2["catch"](2);
+                if (!_this.canRetryError(pendingRetries, _context2.t0)) {
+                  _context2.next = 14;
+                  break;
+                }
+                _context2.next = 13;
+                return delay(backoffMaxDelay / pendingRetries);
+              case 13:
+                return _context2.abrupt("return", _performRequest(pendingRetries - 1));
+              case 14:
+                throw _context2.t0;
+              case 15:
+              case "end":
+                return _context2.stop();
+            }
+          }, _callee2, null, [[2, 8]]);
+        }));
+        return function performRequest() {
+          return _ref2.apply(this, arguments);
+        };
+      }();
+      return _performRequest().then(function (_ref3) {
+        var TeamMembership = _ref3.TeamMembership;
+        return TeamMembership;
+      });
+    }
+
+    /**
+     * Get user information of all members of a team
+     * @param {string} userId
+     * @returns {Promise}
+     */
+  }, {
+    key: "queryUser",
+    value: function queryUser(userId,
+    /**
+     * @private
+     * @deprecated don't need to pass param, value is taken from `this.getCloudId()` instead
+     */
+    cloudId) {
+      var _this2 = this;
+      var userQuery = buildUserQuery(userId, this.getCloudId(cloudId));
+      var _performRequest2 = /*#__PURE__*/function () {
+        var _ref4 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {
+          var pendingRetries,
+            backoffMaxDelay,
+            _args3 = arguments;
+          return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+            while (1) switch (_context3.prev = _context3.next) {
+              case 0:
+                pendingRetries = _args3.length > 0 && _args3[0] !== undefined ? _args3[0] : 3;
+                backoffMaxDelay = _args3.length > 1 && _args3[1] !== undefined ? _args3[1] : 2000;
+                _context3.prev = 2;
+                _context3.next = 5;
+                return _this2.makeGraphQLRequest(userQuery, {
+                  operationName: 'CloudUser'
+                });
+              case 5:
+                return _context3.abrupt("return", _context3.sent);
+              case 8:
+                _context3.prev = 8;
+                _context3.t0 = _context3["catch"](2);
+                if (!_this2.canRetryError(pendingRetries, _context3.t0)) {
+                  _context3.next = 14;
+                  break;
+                }
+                _context3.next = 13;
+                return delay(backoffMaxDelay / pendingRetries);
+              case 13:
+                return _context3.abrupt("return", _performRequest2(pendingRetries - 1));
+              case 14:
+                throw _context3.t0;
+              case 15:
+              case "end":
+                return _context3.stop();
+            }
+          }, _callee3, null, [[2, 8]]);
+        }));
+        return function performRequest() {
+          return _ref4.apply(this, arguments);
+        };
+      }();
+      return _performRequest2();
+    }
+  }]);
+}(BaseGraphQlClient);
+/**
+ * @deprecated As part of decommisioning pf-directoy
+ */
+export var directoryClient = new DirectoryClient(DEFAULT_CONFIG.stargateRoot, {
+  logException: logException
+});

package/dist/esm/services/graphql-client/index.js

@@ -0,0 +1 @@
+export { BaseGraphQlClient } from './main';

package/dist/esm/services/graphql-client/main.js

@@ -0,0 +1,62 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
+import _inherits from "@babel/runtime/helpers/inherits";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+import { DefaultError, GraphQLError } from '../../common/utils/error';
+import { BaseClient } from '../base-client';
+import { handleGraphQLRequest } from './utils';
+export var BaseGraphQlClient = /*#__PURE__*/function (_BaseClient) {
+  function BaseGraphQlClient(serviceUrl, config) {
+    var _this;
+    _classCallCheck(this, BaseGraphQlClient);
+    _this = _callSuper(this, BaseGraphQlClient, [config]);
+    _this.serviceUrl = serviceUrl;
+    return _this;
+  }
+  _inherits(BaseGraphQlClient, _BaseClient);
+  return _createClass(BaseGraphQlClient, [{
+    key: "setServiceUrl",
+    value: function setServiceUrl(serviceUrl) {
+      this.serviceUrl = serviceUrl;
+    }
+  }, {
+    key: "makeGraphQLRequest",
+    value: function () {
+      var _makeGraphQLRequest = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(body) {
+        var options,
+          _args = arguments;
+        return _regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              options = _args.length > 1 && _args[1] !== undefined ? _args[1] : {};
+              _context.prev = 1;
+              return _context.abrupt("return", handleGraphQLRequest(this.serviceUrl, body, options));
+            case 5:
+              _context.prev = 5;
+              _context.t0 = _context["catch"](1);
+              if (!(_context.t0 instanceof GraphQLError)) {
+                _context.next = 9;
+                break;
+              }
+              throw _context.t0;
+            case 9:
+              this.logException(_context.t0, 'UnknownError in GraphQLClient.makeGraphQLRequestWithoutRetries');
+              throw new DefaultError({});
+            case 11:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this, [[1, 5]]);
+      }));
+      function makeGraphQLRequest(_x) {
+        return _makeGraphQLRequest.apply(this, arguments);
+      }
+      return makeGraphQLRequest;
+    }()
+  }]);
+}(BaseClient);

package/dist/esm/services/graphql-client/types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/services/graphql-client/utils/index.js

@@ -0,0 +1,149 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import { GraphQLError, HttpError } from '../../../common/utils/error';
+import { EXPONENTIAL_BACKOFF_RETRY_POLICY, is5xx, isFetchResponse, withExponentialBackoff } from '../../../common/utils/http';
+import { handleResponse } from '../../../common/utils/status-code-handlers-provider';
+export function makeGraphQLRequestWithoutRetries(_x, _x2) {
+  return _makeGraphQLRequestWithoutRetries.apply(this, arguments);
+}
+function _makeGraphQLRequestWithoutRetries() {
+  _makeGraphQLRequestWithoutRetries = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(serviceUrl, body) {
+    var options,
+      operationNameQuery,
+      errorPolicy,
+      url,
+      request,
+      response,
+      errors,
+      _args = arguments;
+    return _regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          options = _args.length > 2 && _args[2] !== undefined ? _args[2] : {};
+          operationNameQuery = options.operationName ? "?q=".concat(options.operationName) : '';
+          errorPolicy = options.errorPolicy || 'none';
+          url = serviceUrl + operationNameQuery;
+          request = fetch(url, {
+            method: 'POST',
+            headers: new Headers({
+              'Content-Type': 'application/json'
+            }),
+            credentials: 'include',
+            body: JSON.stringify(body)
+          }).then(function (res) {
+            if (res.status < 300 || res.status === 400) {
+              return res.json();
+            } else {
+              throw res;
+            }
+          });
+          _context.prev = 5;
+          _context.next = 8;
+          return request;
+        case 8:
+          response = _context.sent;
+          errors = response.errors;
+          if (!errors) {
+            _context.next = 17;
+            break;
+          }
+          if (!(errorPolicy === 'none')) {
+            _context.next = 15;
+            break;
+          }
+          throw GraphQLError.from(errors);
+        case 15:
+          if (!(errorPolicy === 'all')) {
+            _context.next = 17;
+            break;
+          }
+          return _context.abrupt("return", new Promise(function (resolve, reject) {
+            setTimeout(function () {
+              reject(GraphQLError.from(errors));
+            }, 0);
+          }));
+        case 17:
+          return _context.abrupt("return", response.data);
+        case 20:
+          _context.prev = 20;
+          _context.t0 = _context["catch"](5);
+          if (!(_context.t0 instanceof Response)) {
+            _context.next = 24;
+            break;
+          }
+          return _context.abrupt("return", {
+            response: _context.t0
+          });
+        case 24:
+          if (!Object(_context.t0).hasOwnProperty('response')) {
+            _context.next = 26;
+            break;
+          }
+          throw _context.t0;
+        case 26:
+          return _context.abrupt("return", _context.t0);
+        case 27:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee, null, [[5, 20]]);
+  }));
+  return _makeGraphQLRequestWithoutRetries.apply(this, arguments);
+}
+export function handleGraphQLRequest(_x3, _x4) {
+  return _handleGraphQLRequest.apply(this, arguments);
+}
+function _handleGraphQLRequest() {
+  _handleGraphQLRequest = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(serviceUrl, body) {
+    var options,
+      makeGraphQLRequestWithRetries,
+      result,
+      response,
+      status,
+      statusText,
+      traceId,
+      _args2 = arguments;
+    return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          options = _args2.length > 2 && _args2[2] !== undefined ? _args2[2] : {};
+          makeGraphQLRequestWithRetries = withExponentialBackoff(makeGraphQLRequestWithoutRetries, {
+            initial: EXPONENTIAL_BACKOFF_RETRY_POLICY.INITIAL_DELAY,
+            jitter: EXPONENTIAL_BACKOFF_RETRY_POLICY.JITTER,
+            max: EXPONENTIAL_BACKOFF_RETRY_POLICY.MAX_RETRIES,
+            retryIf: function retryIf(data) {
+              return isFetchResponse(data) && is5xx(data.response.status);
+            }
+          });
+          _context2.next = 4;
+          return makeGraphQLRequestWithRetries(serviceUrl, body, options);
+        case 4:
+          result = _context2.sent;
+          response = result === null || result === void 0 ? void 0 : result.response;
+          if (!response) {
+            _context2.next = 13;
+            break;
+          }
+          status = response.status;
+          statusText = response.statusText;
+          traceId = response.headers.get('atl-traceid');
+          handleResponse(response);
+          if (!(status > 400 && status <= 599)) {
+            _context2.next = 13;
+            break;
+          }
+          throw new HttpError({
+            message: statusText,
+            status: status,
+            traceId: traceId !== null && traceId !== void 0 ? traceId : undefined
+          });
+        case 13:
+          return _context2.abrupt("return", result);
+        case 14:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  }));
+  return _handleGraphQLRequest.apply(this, arguments);
+}

package/dist/esm/services/hooks/use-teams-client-setup.js

@@ -0,0 +1,39 @@
+import { useEffect } from 'react';
+import { teamsClient } from '../main';
+import { logInfoMessage } from '../sentry/main';
+
+/**
+ * @deprecated use useTeamsClientSetupNext for named parameters
+ */
+export var useTeamsClientSetup = function useTeamsClientSetup(stargateRoot, cloudId, orgId, principalUserId) {
+  useTeamsClientSetupNext({
+    stargateRoot: stargateRoot,
+    cloudId: cloudId,
+    orgId: orgId,
+    principalUserId: principalUserId
+  });
+};
+export var useTeamsClientSetupNext = function useTeamsClientSetupNext(_ref) {
+  var stargateRoot = _ref.stargateRoot,
+    cloudId = _ref.cloudId,
+    orgId = _ref.orgId,
+    principalUserId = _ref.principalUserId;
+  useEffect(function () {
+    if (!stargateRoot) {
+      return;
+    }
+    teamsClient.setBaseUrl(stargateRoot);
+  }, [stargateRoot]);
+  useEffect(function () {
+    teamsClient.setContext({
+      cloudId: cloudId,
+      orgId: orgId,
+      userId: principalUserId
+    });
+    if (!orgId) {
+      logInfoMessage("No orgId set - useTeamsClientSetup", {
+        cloudId: cloudId
+      });
+    }
+  }, [cloudId, orgId, principalUserId]);
+};

package/dist/esm/services/identity-client/index.js

@@ -0,0 +1,164 @@
+import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
+import _inherits from "@babel/runtime/helpers/inherits";
+var _excluded = ["id"];
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+import { DEFAULT_CONFIG } from '../constants';
+import { RestClient } from '../rest-client';
+import { dataURItoFile, toManageAPIInput, transformUserManageConfig } from './utils';
+var defaultConfig = {
+  serviceUrl: "".concat(DEFAULT_CONFIG.stargateRoot, "/users")
+};
+export var IdentityClient = /*#__PURE__*/function (_RestClient) {
+  function IdentityClient() {
+    var config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    _classCallCheck(this, IdentityClient);
+    return _callSuper(this, IdentityClient, [_objectSpread(_objectSpread({}, defaultConfig), config)]);
+  }
+  _inherits(IdentityClient, _RestClient);
+  return _createClass(IdentityClient, [{
+    key: "getUserManageConfig",
+    value: function () {
+      var _getUserManageConfig = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(userId) {
+        return _regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              return _context.abrupt("return", this.getResourceCached("/".concat(userId, "/manage")).then(function (resp) {
+                return transformUserManageConfig(resp);
+              }));
+            case 1:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this);
+      }));
+      function getUserManageConfig(_x) {
+        return _getUserManageConfig.apply(this, arguments);
+      }
+      return getUserManageConfig;
+    }()
+    /**
+     * @deprecated
+     * User fetchUserAvatarInfo instead
+     */
+  }, {
+    key: "getMyAvatarUploadedStatus",
+    value: (function () {
+      var _getMyAvatarUploadedStatus = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(userId) {
+        return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              return _context2.abrupt("return", this.fetchUserAvatarInfo(userId));
+            case 1:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2, this);
+      }));
+      function getMyAvatarUploadedStatus(_x2) {
+        return _getMyAvatarUploadedStatus.apply(this, arguments);
+      }
+      return getMyAvatarUploadedStatus;
+    }())
+  }, {
+    key: "deleteAvatar",
+    value: function () {
+      var _deleteAvatar = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(userId) {
+        return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
+            case 0:
+              return _context3.abrupt("return", this.deleteResource("/".concat(userId, "/manage/avatar")));
+            case 1:
+            case "end":
+              return _context3.stop();
+          }
+        }, _callee3, this);
+      }));
+      function deleteAvatar(_x3) {
+        return _deleteAvatar.apply(this, arguments);
+      }
+      return deleteAvatar;
+    }()
+  }, {
+    key: "fetchUserAvatarInfo",
+    value: function () {
+      var _fetchUserAvatarInfo = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee4(userId) {
+        return _regeneratorRuntime.wrap(function _callee4$(_context4) {
+          while (1) switch (_context4.prev = _context4.next) {
+            case 0:
+              return _context4.abrupt("return", this.getResource("/".concat(userId, "/manage/avatar")));
+            case 1:
+            case "end":
+              return _context4.stop();
+          }
+        }, _callee4, this);
+      }));
+      function fetchUserAvatarInfo(_x4) {
+        return _fetchUserAvatarInfo.apply(this, arguments);
+      }
+      return fetchUserAvatarInfo;
+    }()
+  }, {
+    key: "updateUser",
+    value: function () {
+      var _updateUser = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee5(_ref) {
+        var id, user;
+        return _regeneratorRuntime.wrap(function _callee5$(_context5) {
+          while (1) switch (_context5.prev = _context5.next) {
+            case 0:
+              id = _ref.id, user = _objectWithoutProperties(_ref, _excluded);
+              return _context5.abrupt("return", this.patchResource("/".concat(id, "/manage/profile"), toManageAPIInput(user)));
+            case 2:
+            case "end":
+              return _context5.stop();
+          }
+        }, _callee5, this);
+      }));
+      function updateUser(_x5) {
+        return _updateUser.apply(this, arguments);
+      }
+      return updateUser;
+    }()
+  }, {
+    key: "updateUserAvatar",
+    value: function () {
+      var _updateUserAvatar = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee6(_ref2) {
+        var id, fileURI, fileObject, formData, response;
+        return _regeneratorRuntime.wrap(function _callee6$(_context6) {
+          while (1) switch (_context6.prev = _context6.next) {
+            case 0:
+              id = _ref2.id, fileURI = _ref2.fileURI;
+              fileObject = dataURItoFile(fileURI);
+              formData = new FormData();
+              formData.append('file', fileObject);
+              _context6.next = 6;
+              return this.makeRequest("/".concat(id, "/manage/avatar"), {
+                method: 'PUT',
+                body: formData
+              });
+            case 6:
+              response = _context6.sent;
+              return _context6.abrupt("return", response.url);
+            case 8:
+            case "end":
+              return _context6.stop();
+          }
+        }, _callee6, this);
+      }));
+      function updateUserAvatar(_x6) {
+        return _updateUserAvatar.apply(this, arguments);
+      }
+      return updateUserAvatar;
+    }()
+  }]);
+}(RestClient);
+export default new IdentityClient();