@atlaskit/teams-client 4.0.0

package/dist/esm/services/main.js

@@ -0,0 +1,1936 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import { TEAMS_CLIENT_EXPERIENCES } from '../common/utils/ufo/constants';
+import { aggClient } from './agg-client';
+import collaborationGraphClient from './collaborationgraph-client';
+import { directoryClient } from './directory-client';
+import identityClient from './identity-client';
+import invitationsClient from './invitations-client';
+import { defaultLegionClient } from './legion-client';
+import mutabilityClient from './mutability-client';
+import objectResolverClient from './object-resolver-client';
+import permsClient from './perms-client';
+import publicApiClient from './public-api-client';
+import teamsInSlackClient from './teams-in-slack-client';
+import userPreferencesClient from './user-preferences-client';
+
+/**
+ * This solves error TS1055:
+ * Type 'ReturnType' is not a valid async function return type in ES5/ES3 because it does not refer to a Promise-compatible constructor value
+ */
+
+/**
+ * The Teams Client is an used for fetching data related to Atlas teams.
+ * It is an abstraction over the various clients that are used to fetch data related to teams.
+ * Find out more about the APIs here - [https://developer.atlassian.com/platform/teams-internal/](https://developer.atlassian.com/platform/teams-internal/)
+ */
+export var TeamsClient = /*#__PURE__*/function () {
+  function TeamsClient(
+  /**
+   * @param {ClientContextProps} context - Context including CloudId & OrgId to be used for all requests
+   */
+  context) {
+    _classCallCheck(this, TeamsClient);
+    _defineProperty(this, "_aggClient", aggClient);
+    _defineProperty(this, "_directoryClient", directoryClient);
+    _defineProperty(this, "_legionClient", defaultLegionClient);
+    _defineProperty(this, "_mutabilityClient", mutabilityClient);
+    _defineProperty(this, "_permsClient", permsClient);
+    _defineProperty(this, "_publicApiClient", publicApiClient);
+    _defineProperty(this, "_invitationsClient", invitationsClient);
+    _defineProperty(this, "_userPreferencesClient", userPreferencesClient);
+    _defineProperty(this, "_objectResolverClient", objectResolverClient);
+    _defineProperty(this, "_teamsInSlackClient", teamsInSlackClient);
+    _defineProperty(this, "_collaborationGraphClient", collaborationGraphClient);
+    _defineProperty(this, "_identityClient", identityClient);
+    if (context) {
+      this.setContext(context);
+    }
+  }
+  return _createClass(TeamsClient, [{
+    key: "measurePerformance",
+    value: function () {
+      var _measurePerformance = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(name, fn) {
+        var exp, result;
+        return _regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              exp = TEAMS_CLIENT_EXPERIENCES.get(name);
+              if (exp) {
+                _context.next = 3;
+                break;
+              }
+              return _context.abrupt("return", fn());
+            case 3:
+              exp.start();
+              _context.prev = 4;
+              _context.next = 7;
+              return fn();
+            case 7:
+              result = _context.sent;
+              exp.success();
+              return _context.abrupt("return", result);
+            case 12:
+              _context.prev = 12;
+              _context.t0 = _context["catch"](4);
+              exp.failWithError(_context.t0);
+              throw _context.t0;
+            case 16:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, null, [[4, 12]]);
+      }));
+      function measurePerformance(_x, _x2) {
+        return _measurePerformance.apply(this, arguments);
+      }
+      return measurePerformance;
+    }()
+    /**
+     * Sets the base URL to be used in the client requests
+     * @param {string} baseUrl - The new base URL
+     */
+  }, {
+    key: "setBaseUrl",
+    value: function setBaseUrl(baseUrl) {
+      this._aggClient.setBaseUrl(baseUrl);
+      this._directoryClient.setBaseUrl(baseUrl);
+    }
+
+    /**
+     * Sets context including CloudId & OrgId to be used for all requests
+     */
+  }, {
+    key: "setContext",
+    value: function setContext(context) {
+      this._aggClient.setContext(context);
+      this._directoryClient.setContext(context);
+      this._legionClient.setContext(context);
+      this._permsClient.setContext(context);
+      this._mutabilityClient.setContext(context);
+      this._publicApiClient.setContext(context);
+      this._invitationsClient.setContext(context);
+    }
+
+    /**
+     * @private
+     * @deprecated use setBaseUrl instead
+     */
+  }, {
+    key: "setDirectoryBaseUrl",
+    value: function setDirectoryBaseUrl(baseUrl) {
+      // eslint-disable-next-line no-console
+      console.warn('setDirectoryBaseUrl is deprecated, use setBaseUrl instead');
+      return this._directoryClient.setBaseUrl(baseUrl);
+    }
+
+    /**
+     * Fetches Browse user settings
+     */
+  }, {
+    key: "querySettings",
+    value: (function () {
+      var _querySettings = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(cloudId, product) {
+        var _this = this;
+        return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
+            case 0:
+              if (cloudId) {
+                this.setContext({
+                  cloudId: cloudId
+                });
+              }
+              return _context3.abrupt("return", this.measurePerformance('querySettings', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+                var response;
+                return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+                  while (1) switch (_context2.prev = _context2.next) {
+                    case 0:
+                      if (product) {
+                        _context2.next = 2;
+                        break;
+                      }
+                      throw new Error('Product is required');
+                    case 2:
+                      _context2.next = 4;
+                      return _this._legionClient.retrieveBrowseUserPermission(product);
+                    case 4:
+                      response = _context2.sent;
+                      return _context2.abrupt("return", {
+                        'internal.browse-users-allowed': response.canSearchUsers
+                      });
+                    case 6:
+                    case "end":
+                      return _context2.stop();
+                  }
+                }, _callee2);
+              }))));
+            case 2:
+            case "end":
+              return _context3.stop();
+          }
+        }, _callee3, this);
+      }));
+      function querySettings(_x3, _x4) {
+        return _querySettings.apply(this, arguments);
+      }
+      return querySettings;
+    }()
+    /**
+     * This will return all of the teams-related permissions that your user has for the org and site in the client context.
+     */
+    )
+  }, {
+    key: "getPermissions",
+    value: (function () {
+      var _getPermissions = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee4() {
+        var _this2 = this;
+        return _regeneratorRuntime.wrap(function _callee4$(_context4) {
+          while (1) switch (_context4.prev = _context4.next) {
+            case 0:
+              return _context4.abrupt("return", this.measurePerformance('getPermissions', function () {
+                return _this2._legionClient.getPermissions();
+              }));
+            case 1:
+            case "end":
+              return _context4.stop();
+          }
+        }, _callee4, this);
+      }));
+      function getPermissions() {
+        return _getPermissions.apply(this, arguments);
+      }
+      return getPermissions;
+    }()
+    /**
+     * Fetches feature flags from Directory
+     * @deprecated As part of decommisioning pf-directoy
+     */
+    )
+  }, {
+    key: "queryFeatureFlags",
+    value: (function () {
+      var _queryFeatureFlags = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee5() {
+        var _this3 = this;
+        var _len,
+          args,
+          _key,
+          _args5 = arguments;
+        return _regeneratorRuntime.wrap(function _callee5$(_context5) {
+          while (1) switch (_context5.prev = _context5.next) {
+            case 0:
+              for (_len = _args5.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+                args[_key] = _args5[_key];
+              }
+              return _context5.abrupt("return", this.measurePerformance('queryFeatureFlags', function () {
+                var _this3$_directoryClie;
+                return (_this3$_directoryClie = _this3._directoryClient).queryFeatureFlags.apply(_this3$_directoryClie, args);
+              }));
+            case 2:
+            case "end":
+              return _context5.stop();
+          }
+        }, _callee5, this);
+      }));
+      function queryFeatureFlags() {
+        return _queryFeatureFlags.apply(this, arguments);
+      }
+      return queryFeatureFlags;
+    }()
+    /**
+     * Get user information of members of a team, paginated
+     * @param {string} teamId
+     * @returns {Promise}
+     */
+    )
+  }, {
+    key: "queryTeamMemberships",
+    value: (function () {
+      var _queryTeamMemberships = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee6(teamId) {
+        var membershipState,
+          pageInfo,
+          _args6 = arguments;
+        return _regeneratorRuntime.wrap(function _callee6$(_context6) {
+          while (1) switch (_context6.prev = _context6.next) {
+            case 0:
+              membershipState = _args6.length > 1 && _args6[1] !== undefined ? _args6[1] : ['FULL_MEMBER'];
+              pageInfo = _args6.length > 2 && _args6[2] !== undefined ? _args6[2] : {
+                first: 100
+              };
+              return _context6.abrupt("return", this._aggClient.queryTeamMemberships(teamId, membershipState, pageInfo));
+            case 3:
+            case "end":
+              return _context6.stop();
+          }
+        }, _callee6, this);
+      }));
+      function queryTeamMemberships(_x5) {
+        return _queryTeamMemberships.apply(this, arguments);
+      }
+      return queryTeamMemberships;
+    }()
+    /**
+     * Get user information given an user id
+     * @param {string} userId
+     * @returns {Promise}
+     */
+    )
+  }, {
+    key: "queryAGGUser",
+    value: (function () {
+      var _queryAGGUser = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee7(userId) {
+        return _regeneratorRuntime.wrap(function _callee7$(_context7) {
+          while (1) switch (_context7.prev = _context7.next) {
+            case 0:
+              return _context7.abrupt("return", this._aggClient.queryAGGUser(userId));
+            case 1:
+            case "end":
+              return _context7.stop();
+          }
+        }, _callee7, this);
+      }));
+      function queryAGGUser(_x6) {
+        return _queryAGGUser.apply(this, arguments);
+      }
+      return queryAGGUser;
+    }()
+    /**
+     * Get user information of a member of a team
+     * @param {string} userId
+     * @returns {Promise<CloudUser>}
+     */
+    )
+  }, {
+    key: "queryUser",
+    value: function queryUser() {
+      var _this4 = this;
+      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+        args[_key2] = arguments[_key2];
+      }
+      return this.measurePerformance('queryUser', function () {
+        var _this4$_directoryClie;
+        return (_this4$_directoryClie = _this4._directoryClient).queryUser.apply(_this4$_directoryClie, args);
+      });
+    }
+  }, {
+    key: "setLegionRootUrl",
+    value: function setLegionRootUrl(url) {
+      return this._legionClient.setRootUrl(url);
+    }
+
+    /**
+     *
+     * @param teamId
+     * @returns {Promise<TeamWithImageUrls>}
+     */
+  }, {
+    key: "getTeamById",
+    value: (function () {
+      var _getTeamById = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee8(teamId) {
+        var _this5 = this;
+        return _regeneratorRuntime.wrap(function _callee8$(_context8) {
+          while (1) switch (_context8.prev = _context8.next) {
+            case 0:
+              return _context8.abrupt("return", this.measurePerformance('getTeamById', function () {
+                return _this5._legionClient.getTeamById(teamId);
+              }));
+            case 1:
+            case "end":
+              return _context8.stop();
+          }
+        }, _callee8, this);
+      }));
+      function getTeamById(_x7) {
+        return _getTeamById.apply(this, arguments);
+      }
+      return getTeamById;
+    }()
+    /**
+     * Search teams based on query
+     */
+    )
+  }, {
+    key: "getAllTeams",
+    value: (function () {
+      var _getAllTeams = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee9() {
+        var _this6 = this;
+        var _len3,
+          args,
+          _key3,
+          _args9 = arguments;
+        return _regeneratorRuntime.wrap(function _callee9$(_context9) {
+          while (1) switch (_context9.prev = _context9.next) {
+            case 0:
+              for (_len3 = _args9.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+                args[_key3] = _args9[_key3];
+              }
+              return _context9.abrupt("return", this.measurePerformance('getAllTeams', function () {
+                var _this6$_legionClient;
+                return (_this6$_legionClient = _this6._legionClient).getAllTeams.apply(_this6$_legionClient, args);
+              }));
+            case 2:
+            case "end":
+              return _context9.stop();
+          }
+        }, _callee9, this);
+      }));
+      function getAllTeams() {
+        return _getAllTeams.apply(this, arguments);
+      }
+      return getAllTeams;
+    }()
+    /**
+     * Update team details
+     */
+    )
+  }, {
+    key: "updateTeamById",
+    value: (function () {
+      var _updateTeamById = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee10() {
+        var _this7 = this;
+        var _len4,
+          args,
+          _key4,
+          _args10 = arguments;
+        return _regeneratorRuntime.wrap(function _callee10$(_context10) {
+          while (1) switch (_context10.prev = _context10.next) {
+            case 0:
+              for (_len4 = _args10.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
+                args[_key4] = _args10[_key4];
+              }
+              return _context10.abrupt("return", this.measurePerformance('updateTeamById', function () {
+                var _this7$_legionClient;
+                return (_this7$_legionClient = _this7._legionClient).updateTeamById.apply(_this7$_legionClient, args);
+              }));
+            case 2:
+            case "end":
+              return _context10.stop();
+          }
+        }, _callee10, this);
+      }));
+      function updateTeamById() {
+        return _updateTeamById.apply(this, arguments);
+      }
+      return updateTeamById;
+    }()
+    /**
+     * @private
+     * @deprecated use addUsersToTeam instead
+     */
+    )
+  }, {
+    key: "inviteUsersToTeam",
+    value: (function () {
+      var _inviteUsersToTeam = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee11() {
+        var _this8 = this;
+        var _len5,
+          args,
+          _key5,
+          _args11 = arguments;
+        return _regeneratorRuntime.wrap(function _callee11$(_context11) {
+          while (1) switch (_context11.prev = _context11.next) {
+            case 0:
+              for (_len5 = _args11.length, args = new Array(_len5), _key5 = 0; _key5 < _len5; _key5++) {
+                args[_key5] = _args11[_key5];
+              }
+              return _context11.abrupt("return", this.measurePerformance('inviteUsersToTeam', function () {
+                var _this8$_legionClient;
+                return (_this8$_legionClient = _this8._legionClient).inviteUsersToTeam.apply(_this8$_legionClient, args);
+              }));
+            case 2:
+            case "end":
+              return _context11.stop();
+          }
+        }, _callee11, this);
+      }));
+      function inviteUsersToTeam() {
+        return _inviteUsersToTeam.apply(this, arguments);
+      }
+      return inviteUsersToTeam;
+    }()
+    /**
+     * Get the current user's team membership
+     */
+    )
+  }, {
+    key: "getMyTeamMembership",
+    value: (function () {
+      var _getMyTeamMembership = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee12() {
+        var _this9 = this;
+        var _len6,
+          args,
+          _key6,
+          _args12 = arguments;
+        return _regeneratorRuntime.wrap(function _callee12$(_context12) {
+          while (1) switch (_context12.prev = _context12.next) {
+            case 0:
+              for (_len6 = _args12.length, args = new Array(_len6), _key6 = 0; _key6 < _len6; _key6++) {
+                args[_key6] = _args12[_key6];
+              }
+              return _context12.abrupt("return", this.measurePerformance('getMyTeamMembership', function () {
+                var _this9$_legionClient;
+                return (_this9$_legionClient = _this9._legionClient).getMyTeamMembership.apply(_this9$_legionClient, args);
+              }));
+            case 2:
+            case "end":
+              return _context12.stop();
+          }
+        }, _callee12, this);
+      }));
+      function getMyTeamMembership() {
+        return _getMyTeamMembership.apply(this, arguments);
+      }
+      return getMyTeamMembership;
+    }()
+    /**
+     * Get a teams "Links"
+     */
+    )
+  }, {
+    key: "getTeamLinksByTeamId",
+    value: (function () {
+      var _getTeamLinksByTeamId = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee13(teamId) {
+        var _this10 = this;
+        return _regeneratorRuntime.wrap(function _callee13$(_context13) {
+          while (1) switch (_context13.prev = _context13.next) {
+            case 0:
+              return _context13.abrupt("return", this.measurePerformance('getTeamLinksByTeamId', function () {
+                return _this10._legionClient.getTeamLinksByTeamId(teamId);
+              }));
+            case 1:
+            case "end":
+              return _context13.stop();
+          }
+        }, _callee13, this);
+      }));
+      function getTeamLinksByTeamId(_x8) {
+        return _getTeamLinksByTeamId.apply(this, arguments);
+      }
+      return getTeamLinksByTeamId;
+    }()
+    /**
+     * Create a team link
+     */
+    )
+  }, {
+    key: "createTeamLink",
+    value: (function () {
+      var _createTeamLink = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee14() {
+        var _this11 = this;
+        var _len7,
+          args,
+          _key7,
+          _args14 = arguments;
+        return _regeneratorRuntime.wrap(function _callee14$(_context14) {
+          while (1) switch (_context14.prev = _context14.next) {
+            case 0:
+              for (_len7 = _args14.length, args = new Array(_len7), _key7 = 0; _key7 < _len7; _key7++) {
+                args[_key7] = _args14[_key7];
+              }
+              return _context14.abrupt("return", this.measurePerformance('createTeamLink', function () {
+                var _this11$_legionClient;
+                return (_this11$_legionClient = _this11._legionClient).createTeamLink.apply(_this11$_legionClient, args);
+              }));
+            case 2:
+            case "end":
+              return _context14.stop();
+          }
+        }, _callee14, this);
+      }));
+      function createTeamLink() {
+        return _createTeamLink.apply(this, arguments);
+      }
+      return createTeamLink;
+    }()
+    /**
+     * Update a team link
+     */
+    )
+  }, {
+    key: "updateTeamLink",
+    value: (function () {
+      var _updateTeamLink = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee15() {
+        var _this12 = this;
+        var _len8,
+          args,
+          _key8,
+          _args15 = arguments;
+        return _regeneratorRuntime.wrap(function _callee15$(_context15) {
+          while (1) switch (_context15.prev = _context15.next) {
+            case 0:
+              for (_len8 = _args15.length, args = new Array(_len8), _key8 = 0; _key8 < _len8; _key8++) {
+                args[_key8] = _args15[_key8];
+              }
+              return _context15.abrupt("return", this.measurePerformance('updateTeamLink', function () {
+                var _this12$_legionClient;
+                return (_this12$_legionClient = _this12._legionClient).updateTeamLink.apply(_this12$_legionClient, args);
+              }));
+            case 2:
+            case "end":
+              return _context15.stop();
+          }
+        }, _callee15, this);
+      }));
+      function updateTeamLink() {
+        return _updateTeamLink.apply(this, arguments);
+      }
+      return updateTeamLink;
+    }()
+    /**
+     * Delete a team link
+     */
+    )
+  }, {
+    key: "deleteTeamLink",
+    value: (function () {
+      var _deleteTeamLink = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee16() {
+        var _this13 = this;
+        var _len9,
+          args,
+          _key9,
+          _args16 = arguments;
+        return _regeneratorRuntime.wrap(function _callee16$(_context16) {
+          while (1) switch (_context16.prev = _context16.next) {
+            case 0:
+              for (_len9 = _args16.length, args = new Array(_len9), _key9 = 0; _key9 < _len9; _key9++) {
+                args[_key9] = _args16[_key9];
+              }
+              return _context16.abrupt("return", this.measurePerformance('deleteTeamLink', function () {
+                var _this13$_legionClient;
+                return (_this13$_legionClient = _this13._legionClient).deleteTeamLink.apply(_this13$_legionClient, args);
+              }));
+            case 2:
+            case "end":
+              return _context16.stop();
+          }
+        }, _callee16, this);
+      }));
+      function deleteTeamLink() {
+        return _deleteTeamLink.apply(this, arguments);
+      }
+      return deleteTeamLink;
+    }()
+    /**
+     * Reorder a team link
+     */
+    )
+  }, {
+    key: "reorderTeamLink",
+    value: (function () {
+      var _reorderTeamLink = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee17() {
+        var _this14 = this;
+        var _len10,
+          args,
+          _key10,
+          _args17 = arguments;
+        return _regeneratorRuntime.wrap(function _callee17$(_context17) {
+          while (1) switch (_context17.prev = _context17.next) {
+            case 0:
+              for (_len10 = _args17.length, args = new Array(_len10), _key10 = 0; _key10 < _len10; _key10++) {
+                args[_key10] = _args17[_key10];
+              }
+              return _context17.abrupt("return", this.measurePerformance('reorderTeamLink', function () {
+                var _this14$_legionClient;
+                return (_this14$_legionClient = _this14._legionClient).reorderTeamLink.apply(_this14$_legionClient, args);
+              }));
+            case 2:
+            case "end":
+              return _context17.stop();
+          }
+        }, _callee17, this);
+      }));
+      function reorderTeamLink() {
+        return _reorderTeamLink.apply(this, arguments);
+      }
+      return reorderTeamLink;
+    }()
+    /**
+     * Get org's eligibility for managed teams
+     */
+    )
+  }, {
+    key: "getOrgEligibilityForManagedTeams",
+    value: (function () {
+      var _getOrgEligibilityForManagedTeams = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee18() {
+        var _this15 = this;
+        return _regeneratorRuntime.wrap(function _callee18$(_context18) {
+          while (1) switch (_context18.prev = _context18.next) {
+            case 0:
+              return _context18.abrupt("return", this.measurePerformance('getOrgEligibilityForManagedTeams', function () {
+                return _this15._legionClient.getOrgEligibilityForManagedTeams();
+              }));
+            case 1:
+            case "end":
+              return _context18.stop();
+          }
+        }, _callee18, this);
+      }));
+      function getOrgEligibilityForManagedTeams() {
+        return _getOrgEligibilityForManagedTeams.apply(this, arguments);
+      }
+      return getOrgEligibilityForManagedTeams;
+    }()
+    /**
+     * @deprecated Invitation status no longer exists
+     * Accept a team invitation
+     */
+    )
+  }, {
+    key: "acceptTeamInvitation",
+    value: (function () {
+      var _acceptTeamInvitation = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee19() {
+        var _this16 = this;
+        var _len11,
+          args,
+          _key11,
+          _args19 = arguments;
+        return _regeneratorRuntime.wrap(function _callee19$(_context19) {
+          while (1) switch (_context19.prev = _context19.next) {
+            case 0:
+              for (_len11 = _args19.length, args = new Array(_len11), _key11 = 0; _key11 < _len11; _key11++) {
+                args[_key11] = _args19[_key11];
+              }
+              return _context19.abrupt("return", this.measurePerformance('acceptTeamInvitation', function () {
+                var _this16$_legionClient;
+                return (_this16$_legionClient = _this16._legionClient).acceptTeamInvitation.apply(_this16$_legionClient, args);
+              }));
+            case 2:
+            case "end":
+              return _context19.stop();
+          }
+        }, _callee19, this);
+      }));
+      function acceptTeamInvitation() {
+        return _acceptTeamInvitation.apply(this, arguments);
+      }
+      return acceptTeamInvitation;
+    }()
+    /**
+     * @deprecated Invitation status no longer exists
+     * Decline a team invitation
+     */
+    )
+  }, {
+    key: "declineTeamInvitation",
+    value: (function () {
+      var _declineTeamInvitation = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee20() {
+        var _this17 = this;
+        var _len12,
+          args,
+          _key12,
+          _args20 = arguments;
+        return _regeneratorRuntime.wrap(function _callee20$(_context20) {
+          while (1) switch (_context20.prev = _context20.next) {
+            case 0:
+              for (_len12 = _args20.length, args = new Array(_len12), _key12 = 0; _key12 < _len12; _key12++) {
+                args[_key12] = _args20[_key12];
+              }
+              return _context20.abrupt("return", this.measurePerformance('declineTeamInvitation', function () {
+                var _this17$_legionClient;
+                return (_this17$_legionClient = _this17._legionClient).declineTeamInvitation.apply(_this17$_legionClient, args);
+              }));
+            case 2:
+            case "end":
+              return _context20.stop();
+          }
+        }, _callee20, this);
+      }));
+      function declineTeamInvitation() {
+        return _declineTeamInvitation.apply(this, arguments);
+      }
+      return declineTeamInvitation;
+    }()
+    /**
+     * Add current user to a team
+     */
+    )
+  }, {
+    key: "selfJoinTeam",
+    value: (function () {
+      var _selfJoinTeam = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee21() {
+        var _this18 = this;
+        var _len13,
+          args,
+          _key13,
+          _args21 = arguments;
+        return _regeneratorRuntime.wrap(function _callee21$(_context21) {
+          while (1) switch (_context21.prev = _context21.next) {
+            case 0:
+              for (_len13 = _args21.length, args = new Array(_len13), _key13 = 0; _key13 < _len13; _key13++) {
+                args[_key13] = _args21[_key13];
+              }
+              return _context21.abrupt("return", this.measurePerformance('selfJoinTeam', function () {
+                var _this18$_legionClient;
+                return (_this18$_legionClient = _this18._legionClient).selfJoinTeam.apply(_this18$_legionClient, args);
+              }));
+            case 2:
+            case "end":
+              return _context21.stop();
+          }
+        }, _callee21, this);
+      }));
+      function selfJoinTeam() {
+        return _selfJoinTeam.apply(this, arguments);
+      }
+      return selfJoinTeam;
+    }()
+    /**
+     * Cancel a join request to a private team
+     */
+    )
+  }, {
+    key: "cancelJoinRequest",
+    value: (function () {
+      var _cancelJoinRequest = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee22(teamId) {
+        var _this19 = this;
+        return _regeneratorRuntime.wrap(function _callee22$(_context22) {
+          while (1) switch (_context22.prev = _context22.next) {
+            case 0:
+              return _context22.abrupt("return", this.measurePerformance('cancelJoinRequest', function () {
+                return _this19._legionClient.cancelJoinRequest(teamId);
+              }));
+            case 1:
+            case "end":
+              return _context22.stop();
+          }
+        }, _callee22, this);
+      }));
+      function cancelJoinRequest(_x9) {
+        return _cancelJoinRequest.apply(this, arguments);
+      }
+      return cancelJoinRequest;
+    }()
+    /**
+     * Accept a join request to a private team
+     */
+    )
+  }, {
+    key: "acceptJoinRequest",
+    value: (function () {
+      var _acceptJoinRequest = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee23() {
+        var _this20 = this;
+        var _len14,
+          args,
+          _key14,
+          _args23 = arguments;
+        return _regeneratorRuntime.wrap(function _callee23$(_context23) {
+          while (1) switch (_context23.prev = _context23.next) {
+            case 0:
+              for (_len14 = _args23.length, args = new Array(_len14), _key14 = 0; _key14 < _len14; _key14++) {
+                args[_key14] = _args23[_key14];
+              }
+              return _context23.abrupt("return", this.measurePerformance('acceptJoinRequest', function () {
+                var _this20$_legionClient;
+                return (_this20$_legionClient = _this20._legionClient).acceptJoinRequest.apply(_this20$_legionClient, args);
+              }));
+            case 2:
+            case "end":
+              return _context23.stop();
+          }
+        }, _callee23, this);
+      }));
+      function acceptJoinRequest() {
+        return _acceptJoinRequest.apply(this, arguments);
+      }
+      return acceptJoinRequest;
+    }()
+    /**
+     * Decline a join request to a private team
+     */
+    )
+  }, {
+    key: "declineJoinRequest",
+    value: (function () {
+      var _declineJoinRequest = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee24() {
+        var _this21 = this;
+        var _len15,
+          args,
+          _key15,
+          _args24 = arguments;
+        return _regeneratorRuntime.wrap(function _callee24$(_context24) {
+          while (1) switch (_context24.prev = _context24.next) {
+            case 0:
+              for (_len15 = _args24.length, args = new Array(_len15), _key15 = 0; _key15 < _len15; _key15++) {
+                args[_key15] = _args24[_key15];
+              }
+              return _context24.abrupt("return", this.measurePerformance('declineJoinRequest', function () {
+                var _this21$_legionClient;
+                return (_this21$_legionClient = _this21._legionClient).declineJoinRequest.apply(_this21$_legionClient, args);
+              }));
+            case 2:
+            case "end":
+              return _context24.stop();
+          }
+        }, _callee24, this);
+      }));
+      function declineJoinRequest() {
+        return _declineJoinRequest.apply(this, arguments);
+      }
+      return declineJoinRequest;
+    }()
+    /**
+     * @deprecated use removeTeamMemberships instead
+     */
+    )
+  }, {
+    key: "deleteTeamMembership",
+    value: (function () {
+      var _deleteTeamMembership = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee25() {
+        var _this22 = this;
+        var _len16,
+          args,
+          _key16,
+          _args25 = arguments;
+        return _regeneratorRuntime.wrap(function _callee25$(_context25) {
+          while (1) switch (_context25.prev = _context25.next) {
+            case 0:
+              for (_len16 = _args25.length, args = new Array(_len16), _key16 = 0; _key16 < _len16; _key16++) {
+                args[_key16] = _args25[_key16];
+              }
+              return _context25.abrupt("return", this.measurePerformance('deleteTeamMembership', function () {
+                var _this22$_legionClient;
+                return (_this22$_legionClient = _this22._legionClient).deleteTeamMembership.apply(_this22$_legionClient, args);
+              }));
+            case 2:
+            case "end":
+              return _context25.stop();
+          }
+        }, _callee25, this);
+      }));
+      function deleteTeamMembership() {
+        return _deleteTeamMembership.apply(this, arguments);
+      }
+      return deleteTeamMembership;
+    }()
+    /**
+     * @deprecated INVITED status has been deprecated
+     */
+    )
+  }, {
+    key: "revokeTeamInvite",
+    value: (function () {
+      var _revokeTeamInvite = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee26() {
+        var _this23 = this;
+        var _len17,
+          args,
+          _key17,
+          _args26 = arguments;
+        return _regeneratorRuntime.wrap(function _callee26$(_context26) {
+          while (1) switch (_context26.prev = _context26.next) {
+            case 0:
+              for (_len17 = _args26.length, args = new Array(_len17), _key17 = 0; _key17 < _len17; _key17++) {
+                args[_key17] = _args26[_key17];
+              }
+              return _context26.abrupt("return", this.measurePerformance('revokeTeamInvite', function () {
+                var _this23$_legionClient;
+                return (_this23$_legionClient = _this23._legionClient).revokeTeamInvite.apply(_this23$_legionClient, args);
+              }));
+            case 2:
+            case "end":
+              return _context26.stop();
+          }
+        }, _callee26, this);
+      }));
+      function revokeTeamInvite() {
+        return _revokeTeamInvite.apply(this, arguments);
+      }
+      return revokeTeamInvite;
+    }()
+    /**
+     * Delete a team
+     */
+    )
+  }, {
+    key: "deleteTeam",
+    value: (function () {
+      var _deleteTeam = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee27(teamId) {
+        var _this24 = this;
+        return _regeneratorRuntime.wrap(function _callee27$(_context27) {
+          while (1) switch (_context27.prev = _context27.next) {
+            case 0:
+              return _context27.abrupt("return", this.measurePerformance('deleteTeam', function () {
+                return _this24._legionClient.deleteTeam(teamId);
+              }));
+            case 1:
+            case "end":
+              return _context27.stop();
+          }
+        }, _callee27, this);
+      }));
+      function deleteTeam(_x10) {
+        return _deleteTeam.apply(this, arguments);
+      }
+      return deleteTeam;
+    }()
+    /**
+     * @private
+     * @deprecated should be other means to solve this issue
+     */
+    )
+  }, {
+    key: "isSingleFullMemberTeam",
+    value: (function () {
+      var _isSingleFullMemberTeam = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee28(teamId) {
+        return _regeneratorRuntime.wrap(function _callee28$(_context28) {
+          while (1) switch (_context28.prev = _context28.next) {
+            case 0:
+              return _context28.abrupt("return", this._legionClient.isSingleFullMemberTeam(teamId));
+            case 1:
+            case "end":
+              return _context28.stop();
+          }
+        }, _callee28, this);
+      }));
+      function isSingleFullMemberTeam(_x11) {
+        return _isSingleFullMemberTeam.apply(this, arguments);
+      }
+      return isSingleFullMemberTeam;
+    }()
+    /**
+     * Create a team
+     */
+    )
+  }, {
+    key: "createTeam",
+    value: (function () {
+      var _createTeam = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee29() {
+        var _this25 = this;
+        var _len18,
+          args,
+          _key18,
+          _args29 = arguments;
+        return _regeneratorRuntime.wrap(function _callee29$(_context29) {
+          while (1) switch (_context29.prev = _context29.next) {
+            case 0:
+              for (_len18 = _args29.length, args = new Array(_len18), _key18 = 0; _key18 < _len18; _key18++) {
+                args[_key18] = _args29[_key18];
+              }
+              return _context29.abrupt("return", this.measurePerformance('createTeam', function () {
+                var _this25$_legionClient;
+                return (_this25$_legionClient = _this25._legionClient).createTeam.apply(_this25$_legionClient, args);
+              }));
+            case 2:
+            case "end":
+              return _context29.stop();
+          }
+        }, _callee29, this);
+      }));
+      function createTeam() {
+        return _createTeam.apply(this, arguments);
+      }
+      return createTeam;
+    }()
+    /**
+     * Create a external team
+     * @param {string} groupDescription - The description of the group, which will be used as the team description. The group name will be fetched from the identity service, so it does not need to be provided.
+     * @param {ExternalReference} externalReference
+     */
+    )
+  }, {
+    key: "createExternalTeam",
+    value: (function () {
+      var _createExternalTeam = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee30() {
+        var _this26 = this;
+        var _len19,
+          args,
+          _key19,
+          _args30 = arguments;
+        return _regeneratorRuntime.wrap(function _callee30$(_context30) {
+          while (1) switch (_context30.prev = _context30.next) {
+            case 0:
+              for (_len19 = _args30.length, args = new Array(_len19), _key19 = 0; _key19 < _len19; _key19++) {
+                args[_key19] = _args30[_key19];
+              }
+              return _context30.abrupt("return", this.measurePerformance('createExternalTeam', function () {
+                var _this26$_legionClient;
+                return (_this26$_legionClient = _this26._legionClient).createExternalTeam.apply(_this26$_legionClient, args);
+              }));
+            case 2:
+            case "end":
+              return _context30.stop();
+          }
+        }, _callee30, this);
+      }));
+      function createExternalTeam() {
+        return _createExternalTeam.apply(this, arguments);
+      }
+      return createExternalTeam;
+    }()
+    /**
+     * Get linked teams for a groups in bulk
+     * @param {string} groupIds - The group ids to fetch linked teams for
+     */
+    )
+  }, {
+    key: "getLinkedTeamsBulk",
+    value: (function () {
+      var _getLinkedTeamsBulk = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee31() {
+        var _this27 = this;
+        var _len20,
+          args,
+          _key20,
+          _args31 = arguments;
+        return _regeneratorRuntime.wrap(function _callee31$(_context31) {
+          while (1) switch (_context31.prev = _context31.next) {
+            case 0:
+              for (_len20 = _args31.length, args = new Array(_len20), _key20 = 0; _key20 < _len20; _key20++) {
+                args[_key20] = _args31[_key20];
+              }
+              return _context31.abrupt("return", this.measurePerformance('getLinkedTeamsBulk', function () {
+                var _this27$_legionClient;
+                return (_this27$_legionClient = _this27._legionClient).getLinkedTeamsBulk.apply(_this27$_legionClient, args);
+              }));
+            case 2:
+            case "end":
+              return _context31.stop();
+          }
+        }, _callee31, this);
+      }));
+      function getLinkedTeamsBulk() {
+        return _getLinkedTeamsBulk.apply(this, arguments);
+      }
+      return getLinkedTeamsBulk;
+    }()
+    /**
+     * Get Org scope
+     */
+    )
+  }, {
+    key: "getOrgScope",
+    value: (function () {
+      var _getOrgScope = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee32() {
+        var _this28 = this;
+        var _len21,
+          args,
+          _key21,
+          _args32 = arguments;
+        return _regeneratorRuntime.wrap(function _callee32$(_context32) {
+          while (1) switch (_context32.prev = _context32.next) {
+            case 0:
+              for (_len21 = _args32.length, args = new Array(_len21), _key21 = 0; _key21 < _len21; _key21++) {
+                args[_key21] = _args32[_key21];
+              }
+              return _context32.abrupt("return", this.measurePerformance('getOrgScope', function () {
+                var _this28$_legionClient;
+                return (_this28$_legionClient = _this28._legionClient).getOrgScope.apply(_this28$_legionClient, args);
+              }));
+            case 2:
+            case "end":
+              return _context32.stop();
+          }
+        }, _callee32, this);
+      }));
+      function getOrgScope() {
+        return _getOrgScope.apply(this, arguments);
+      }
+      return getOrgScope;
+    }()
+    /**
+     * Restore soft-deleted team and sync to group
+     */
+    )
+  }, {
+    key: "restoreTeamToSyncedGroup",
+    value: (function () {
+      var _restoreTeamToSyncedGroup = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee33() {
+        var _this29 = this;
+        var _len22,
+          args,
+          _key22,
+          _args33 = arguments;
+        return _regeneratorRuntime.wrap(function _callee33$(_context33) {
+          while (1) switch (_context33.prev = _context33.next) {
+            case 0:
+              for (_len22 = _args33.length, args = new Array(_len22), _key22 = 0; _key22 < _len22; _key22++) {
+                args[_key22] = _args33[_key22];
+              }
+              return _context33.abrupt("return", this.measurePerformance('restoreTeamToSyncedGroup', function () {
+                var _this29$_legionClient;
+                return (_this29$_legionClient = _this29._legionClient).restoreTeamToSyncedGroup.apply(_this29$_legionClient, args);
+              }));
+            case 2:
+            case "end":
+              return _context33.stop();
+          }
+        }, _callee33, this);
+      }));
+      function restoreTeamToSyncedGroup() {
+        return _restoreTeamToSyncedGroup.apply(this, arguments);
+      }
+      return restoreTeamToSyncedGroup;
+    }()
+    /**
+     * Get the difference between a team and a group
+     * @param teamId
+     * @param {ExternalReference} externalReference
+     * @returns {Promise<TeamAndGroupDifference>}
+     */
+    )
+  }, {
+    key: "getTeamAndGroupDiff",
+    value: (function () {
+      var _getTeamAndGroupDiff = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee34() {
+        var _this30 = this;
+        var _len23,
+          args,
+          _key23,
+          _args34 = arguments;
+        return _regeneratorRuntime.wrap(function _callee34$(_context34) {
+          while (1) switch (_context34.prev = _context34.next) {
+            case 0:
+              for (_len23 = _args34.length, args = new Array(_len23), _key23 = 0; _key23 < _len23; _key23++) {
+                args[_key23] = _args34[_key23];
+              }
+              return _context34.abrupt("return", this.measurePerformance('getTeamAndGroupDiff', function () {
+                var _this30$_legionClient;
+                return (_this30$_legionClient = _this30._legionClient).getTeamAndGroupDiff.apply(_this30$_legionClient, args);
+              }));
+            case 2:
+            case "end":
+              return _context34.stop();
+          }
+        }, _callee34, this);
+      }));
+      function getTeamAndGroupDiff() {
+        return _getTeamAndGroupDiff.apply(this, arguments);
+      }
+      return getTeamAndGroupDiff;
+    }()
+    /**
+     * Link an existing team to a group
+     * @param teamId
+     * @param {ExternalReference} externalReference
+     */
+    )
+  }, {
+    key: "linkExistingTeamToGroup",
+    value: (function () {
+      var _linkExistingTeamToGroup = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee35() {
+        var _this31 = this;
+        var _len24,
+          args,
+          _key24,
+          _args35 = arguments;
+        return _regeneratorRuntime.wrap(function _callee35$(_context35) {
+          while (1) switch (_context35.prev = _context35.next) {
+            case 0:
+              for (_len24 = _args35.length, args = new Array(_len24), _key24 = 0; _key24 < _len24; _key24++) {
+                args[_key24] = _args35[_key24];
+              }
+              return _context35.abrupt("return", this.measurePerformance('linkExistingTeamToGroup', function () {
+                var _this31$_legionClient;
+                return (_this31$_legionClient = _this31._legionClient).linkExistingTeamToGroup.apply(_this31$_legionClient, args);
+              }));
+            case 2:
+            case "end":
+              return _context35.stop();
+          }
+        }, _callee35, this);
+      }));
+      function linkExistingTeamToGroup() {
+        return _linkExistingTeamToGroup.apply(this, arguments);
+      }
+      return linkExistingTeamToGroup;
+    }()
+    /**
+     *
+     * @param teamId
+     * @returns {Promise<LinkedTeamsProfileDetails>}
+     */
+    )
+  }, {
+    key: "getTeamProfileDetailsByTeamId",
+    value: (function () {
+      var _getTeamProfileDetailsByTeamId = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee36() {
+        var _this32 = this;
+        var _len25,
+          args,
+          _key25,
+          _args36 = arguments;
+        return _regeneratorRuntime.wrap(function _callee36$(_context36) {
+          while (1) switch (_context36.prev = _context36.next) {
+            case 0:
+              for (_len25 = _args36.length, args = new Array(_len25), _key25 = 0; _key25 < _len25; _key25++) {
+                args[_key25] = _args36[_key25];
+              }
+              return _context36.abrupt("return", this.measurePerformance('getTeamProfileDetails', function () {
+                var _this32$_legionClient;
+                return (_this32$_legionClient = _this32._legionClient).getTeamProfileDetails.apply(_this32$_legionClient, args);
+              }));
+            case 2:
+            case "end":
+              return _context36.stop();
+          }
+        }, _callee36, this);
+      }));
+      function getTeamProfileDetailsByTeamId() {
+        return _getTeamProfileDetailsByTeamId.apply(this, arguments);
+      }
+      return getTeamProfileDetailsByTeamId;
+    }()
+    /**
+     *
+     * @param teamId
+     * @returns {Promise<SoftDeletedTeam>}
+     */
+    )
+  }, {
+    key: "getSoftDeletdTeamById",
+    value: (function () {
+      var _getSoftDeletdTeamById = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee37(teamId) {
+        var _this33 = this;
+        return _regeneratorRuntime.wrap(function _callee37$(_context37) {
+          while (1) switch (_context37.prev = _context37.next) {
+            case 0:
+              return _context37.abrupt("return", this.measurePerformance('getSoftDeletedTeamById', function () {
+                return _this33._legionClient.getSoftDeletedTeamById(teamId);
+              }));
+            case 1:
+            case "end":
+              return _context37.stop();
+          }
+        }, _callee37, this);
+      }));
+      function getSoftDeletdTeamById(_x12) {
+        return _getSoftDeletdTeamById.apply(this, arguments);
+      }
+      return getSoftDeletdTeamById;
+    }()
+    /**
+     * Shoud only be used within Teams (P&T) packages
+     * @param userId
+     * @returns {Promise<SoftDeletedTeam>}
+     */
+    )
+  }, {
+    key: "getUserInSiteUserBase",
+    value: (function () {
+      var _getUserInSiteUserBase = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee38(userId) {
+        var _this34 = this;
+        return _regeneratorRuntime.wrap(function _callee38$(_context38) {
+          while (1) switch (_context38.prev = _context38.next) {
+            case 0:
+              return _context38.abrupt("return", this.measurePerformance('getUserInSiteUserBase', function () {
+                return _this34._legionClient.getUserInSiteUserBase(userId);
+              }));
+            case 1:
+            case "end":
+              return _context38.stop();
+          }
+        }, _callee38, this);
+      }));
+      function getUserInSiteUserBase(_x13) {
+        return _getUserInSiteUserBase.apply(this, arguments);
+      }
+      return getUserInSiteUserBase;
+    }())
+  }, {
+    key: "trimTeamARI",
+    value: function trimTeamARI() {
+      var teamId = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+      return this._legionClient.trimTeamARI(teamId);
+    }
+
+    /**
+     * Get user profile with mutability constraints
+     */
+  }, {
+    key: "getProfileWithMutability",
+    value: (function () {
+      var _getProfileWithMutability = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee39() {
+        var _this35 = this;
+        var _len26,
+          args,
+          _key26,
+          _args39 = arguments;
+        return _regeneratorRuntime.wrap(function _callee39$(_context39) {
+          while (1) switch (_context39.prev = _context39.next) {
+            case 0:
+              for (_len26 = _args39.length, args = new Array(_len26), _key26 = 0; _key26 < _len26; _key26++) {
+                args[_key26] = _args39[_key26];
+              }
+              return _context39.abrupt("return", this.measurePerformance('getProfileWithMutability', function () {
+                var _this35$_mutabilityCl;
+                return (_this35$_mutabilityCl = _this35._mutabilityClient).getProfileWithMutability.apply(_this35$_mutabilityCl, args);
+              }));
+            case 2:
+            case "end":
+              return _context39.stop();
+          }
+        }, _callee39, this);
+      }));
+      function getProfileWithMutability() {
+        return _getProfileWithMutability.apply(this, arguments);
+      }
+      return getProfileWithMutability;
+    }()
+    /**
+     * Is the current user a site admin
+     */
+    )
+  }, {
+    key: "getIsSiteAdmin",
+    value: function getIsSiteAdmin() {
+      var _this36 = this;
+      for (var _len27 = arguments.length, args = new Array(_len27), _key27 = 0; _key27 < _len27; _key27++) {
+        args[_key27] = arguments[_key27];
+      }
+      return this.measurePerformance('getIsSiteAdmin', function () {
+        var _this36$_permsClient;
+        return (_this36$_permsClient = _this36._permsClient).getIsSiteAdmin.apply(_this36$_permsClient, args);
+      });
+    }
+
+    /**
+     * Add users to a team
+     */
+  }, {
+    key: "addUsersToTeam",
+    value: function addUsersToTeam() {
+      var _this37 = this;
+      for (var _len28 = arguments.length, args = new Array(_len28), _key28 = 0; _key28 < _len28; _key28++) {
+        args[_key28] = arguments[_key28];
+      }
+      return this.measurePerformance('addUsersToTeam', function () {
+        var _this37$_publicApiCli;
+        return (_this37$_publicApiCli = _this37._publicApiClient).addUsersToTeam.apply(_this37$_publicApiCli, args);
+      });
+    }
+
+    /**
+     * Remove users from a team
+     */
+  }, {
+    key: "removeTeamMemberships",
+    value: function removeTeamMemberships() {
+      var _this38 = this;
+      for (var _len29 = arguments.length, args = new Array(_len29), _key29 = 0; _key29 < _len29; _key29++) {
+        args[_key29] = arguments[_key29];
+      }
+      return this.measurePerformance('removeTeamMemberships', function () {
+        var _this38$_publicApiCli;
+        return (_this38$_publicApiCli = _this38._publicApiClient).removeTeamMemberships.apply(_this38$_publicApiCli, args);
+      });
+    }
+
+    /**
+     * Restore a deleted team
+     */
+  }, {
+    key: "restoreTeam",
+    value: function restoreTeam() {
+      var _this39 = this;
+      for (var _len30 = arguments.length, args = new Array(_len30), _key30 = 0; _key30 < _len30; _key30++) {
+        args[_key30] = arguments[_key30];
+      }
+      return this.measurePerformance('restoreTeam', function () {
+        var _this39$_publicApiCli;
+        return (_this39$_publicApiCli = _this39._publicApiClient).restoreTeam.apply(_this39$_publicApiCli, args);
+      });
+    }
+  }, {
+    key: "getRecommendedProducts",
+    value: function getRecommendedProducts() {
+      var _this40 = this;
+      for (var _len31 = arguments.length, args = new Array(_len31), _key31 = 0; _key31 < _len31; _key31++) {
+        args[_key31] = arguments[_key31];
+      }
+      return this.measurePerformance('getRecommendedProducts', function () {
+        var _this40$_invitationsC;
+        return (_this40$_invitationsC = _this40._invitationsClient).getProductRecommendations.apply(_this40$_invitationsC, args);
+      });
+    }
+  }, {
+    key: "joinOrRequestDefaultAccessToProductsBulk",
+    value: function joinOrRequestDefaultAccessToProductsBulk() {
+      var _this41 = this;
+      for (var _len32 = arguments.length, args = new Array(_len32), _key32 = 0; _key32 < _len32; _key32++) {
+        args[_key32] = arguments[_key32];
+      }
+      return this.measurePerformance('joinOrRequestDefaultAccessToProductsBulk', function () {
+        var _this41$_invitationsC;
+        return (_this41$_invitationsC = _this41._invitationsClient).joinOrRequestDefaultAccessToProductsBulk.apply(_this41$_invitationsC, args);
+      });
+    }
+
+    /**
+     * Get token to upload media for a team
+     */
+  }, {
+    key: "getWriteTeamMediaToken",
+    value: (function () {
+      var _getWriteTeamMediaToken = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee40() {
+        var _this42 = this;
+        return _regeneratorRuntime.wrap(function _callee40$(_context40) {
+          while (1) switch (_context40.prev = _context40.next) {
+            case 0:
+              return _context40.abrupt("return", this.measurePerformance('getWriteTeamMediaToken', function () {
+                return _this42._legionClient.getWriteMediaToken();
+              }));
+            case 1:
+            case "end":
+              return _context40.stop();
+          }
+        }, _callee40, this);
+      }));
+      function getWriteTeamMediaToken() {
+        return _getWriteTeamMediaToken.apply(this, arguments);
+      }
+      return getWriteTeamMediaToken;
+    }()
+    /**
+     * Get token to read media for a user
+     */
+    )
+  }, {
+    key: "getReadMediaToken",
+    value: (function () {
+      var _getReadMediaToken = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee41() {
+        var _this43 = this;
+        var _len33,
+          args,
+          _key33,
+          _args41 = arguments;
+        return _regeneratorRuntime.wrap(function _callee41$(_context41) {
+          while (1) switch (_context41.prev = _context41.next) {
+            case 0:
+              for (_len33 = _args41.length, args = new Array(_len33), _key33 = 0; _key33 < _len33; _key33++) {
+                args[_key33] = _args41[_key33];
+              }
+              return _context41.abrupt("return", this.measurePerformance('getReadMediaToken', function () {
+                var _this43$_userPreferen;
+                return (_this43$_userPreferen = _this43._userPreferencesClient).getReadMediaToken.apply(_this43$_userPreferen, args);
+              }));
+            case 2:
+            case "end":
+              return _context41.stop();
+          }
+        }, _callee41, this);
+      }));
+      function getReadMediaToken() {
+        return _getReadMediaToken.apply(this, arguments);
+      }
+      return getReadMediaToken;
+    }()
+    /**
+     * Get token to upload media for a user
+     */
+    )
+  }, {
+    key: "getWriteUserMediaToken",
+    value: (function () {
+      var _getWriteUserMediaToken = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee42() {
+        var _this44 = this;
+        return _regeneratorRuntime.wrap(function _callee42$(_context42) {
+          while (1) switch (_context42.prev = _context42.next) {
+            case 0:
+              return _context42.abrupt("return", this.measurePerformance('getWriteUserMediaToken', function () {
+                return _this44._userPreferencesClient.getWriteMediaToken();
+              }));
+            case 1:
+            case "end":
+              return _context42.stop();
+          }
+        }, _callee42, this);
+      }));
+      function getWriteUserMediaToken() {
+        return _getWriteUserMediaToken.apply(this, arguments);
+      }
+      return getWriteUserMediaToken;
+    }()
+    /**
+     * Update header image for a user
+     */
+    )
+  }, {
+    key: "updateUserHeaderImage",
+    value: (function () {
+      var _updateUserHeaderImage = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee43(headerImageId) {
+        var _this45 = this;
+        return _regeneratorRuntime.wrap(function _callee43$(_context43) {
+          while (1) switch (_context43.prev = _context43.next) {
+            case 0:
+              return _context43.abrupt("return", this.measurePerformance('updateUserHeaderImage', function () {
+                return _this45._userPreferencesClient.updateUserHeaderImage(headerImageId);
+              }));
+            case 1:
+            case "end":
+              return _context43.stop();
+          }
+        }, _callee43, this);
+      }));
+      function updateUserHeaderImage(_x14) {
+        return _updateUserHeaderImage.apply(this, arguments);
+      }
+      return updateUserHeaderImage;
+    }()
+    /**
+     * Fetch user containers from collboration graph
+     */
+    )
+  }, {
+    key: "getUserContainers",
+    value: (function () {
+      var _getUserContainers = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee44() {
+        var _this46 = this;
+        var _len34,
+          args,
+          _key34,
+          _args44 = arguments;
+        return _regeneratorRuntime.wrap(function _callee44$(_context44) {
+          while (1) switch (_context44.prev = _context44.next) {
+            case 0:
+              for (_len34 = _args44.length, args = new Array(_len34), _key34 = 0; _key34 < _len34; _key34++) {
+                args[_key34] = _args44[_key34];
+              }
+              return _context44.abrupt("return", this.measurePerformance('getUserContainers', function () {
+                var _this46$_collaboratio;
+                return (_this46$_collaboratio = _this46._collaborationGraphClient).getUserContainers.apply(_this46$_collaboratio, args);
+              }));
+            case 2:
+            case "end":
+              return _context44.stop();
+          }
+        }, _callee44, this);
+      }));
+      function getUserContainers() {
+        return _getUserContainers.apply(this, arguments);
+      }
+      return getUserContainers;
+    }()
+    /**
+     * Fetch mutatability of external managed user fields
+     */
+    )
+  }, {
+    key: "getUserManageConfig",
+    value: (function () {
+      var _getUserManageConfig = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee45() {
+        var _this47 = this;
+        var _len35,
+          args,
+          _key35,
+          _args45 = arguments;
+        return _regeneratorRuntime.wrap(function _callee45$(_context45) {
+          while (1) switch (_context45.prev = _context45.next) {
+            case 0:
+              for (_len35 = _args45.length, args = new Array(_len35), _key35 = 0; _key35 < _len35; _key35++) {
+                args[_key35] = _args45[_key35];
+              }
+              return _context45.abrupt("return", this.measurePerformance('getUserManageConfig', function () {
+                var _this47$_identityClie;
+                return (_this47$_identityClie = _this47._identityClient).getUserManageConfig.apply(_this47$_identityClie, args);
+              }));
+            case 2:
+            case "end":
+              return _context45.stop();
+          }
+        }, _callee45, this);
+      }));
+      function getUserManageConfig() {
+        return _getUserManageConfig.apply(this, arguments);
+      }
+      return getUserManageConfig;
+    }()
+    /**
+     * Fetch user avatar uploaded status
+     */
+    )
+  }, {
+    key: "getMyAvatarUploadedStatus",
+    value: (function () {
+      var _getMyAvatarUploadedStatus = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee46() {
+        var _this48 = this;
+        var _len36,
+          args,
+          _key36,
+          _args46 = arguments;
+        return _regeneratorRuntime.wrap(function _callee46$(_context46) {
+          while (1) switch (_context46.prev = _context46.next) {
+            case 0:
+              for (_len36 = _args46.length, args = new Array(_len36), _key36 = 0; _key36 < _len36; _key36++) {
+                args[_key36] = _args46[_key36];
+              }
+              return _context46.abrupt("return", this.measurePerformance('getMyAvatarUploadedStatus', function () {
+                var _this48$_identityClie;
+                return (_this48$_identityClie = _this48._identityClient).getMyAvatarUploadedStatus.apply(_this48$_identityClie, args);
+              }));
+            case 2:
+            case "end":
+              return _context46.stop();
+          }
+        }, _callee46, this);
+      }));
+      function getMyAvatarUploadedStatus() {
+        return _getMyAvatarUploadedStatus.apply(this, arguments);
+      }
+      return getMyAvatarUploadedStatus;
+    }()
+    /**
+     * Delete user avatar
+     */
+    )
+  }, {
+    key: "deleteAvatar",
+    value: (function () {
+      var _deleteAvatar = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee47() {
+        var _this49 = this;
+        var _len37,
+          args,
+          _key37,
+          _args47 = arguments;
+        return _regeneratorRuntime.wrap(function _callee47$(_context47) {
+          while (1) switch (_context47.prev = _context47.next) {
+            case 0:
+              for (_len37 = _args47.length, args = new Array(_len37), _key37 = 0; _key37 < _len37; _key37++) {
+                args[_key37] = _args47[_key37];
+              }
+              return _context47.abrupt("return", this.measurePerformance('deleteUserAvatar', function () {
+                var _this49$_identityClie;
+                return (_this49$_identityClie = _this49._identityClient).deleteAvatar.apply(_this49$_identityClie, args);
+              }));
+            case 2:
+            case "end":
+              return _context47.stop();
+          }
+        }, _callee47, this);
+      }));
+      function deleteAvatar() {
+        return _deleteAvatar.apply(this, arguments);
+      }
+      return deleteAvatar;
+    }())
+  }, {
+    key: "fetchUserAvatarInfo",
+    value: function () {
+      var _fetchUserAvatarInfo = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee48() {
+        var _this50 = this;
+        var _len38,
+          args,
+          _key38,
+          _args48 = arguments;
+        return _regeneratorRuntime.wrap(function _callee48$(_context48) {
+          while (1) switch (_context48.prev = _context48.next) {
+            case 0:
+              for (_len38 = _args48.length, args = new Array(_len38), _key38 = 0; _key38 < _len38; _key38++) {
+                args[_key38] = _args48[_key38];
+              }
+              return _context48.abrupt("return", this.measurePerformance('fetchUserAvatarInfo', function () {
+                var _this50$_identityClie;
+                return (_this50$_identityClie = _this50._identityClient).fetchUserAvatarInfo.apply(_this50$_identityClie, args);
+              }));
+            case 2:
+            case "end":
+              return _context48.stop();
+          }
+        }, _callee48, this);
+      }));
+      function fetchUserAvatarInfo() {
+        return _fetchUserAvatarInfo.apply(this, arguments);
+      }
+      return fetchUserAvatarInfo;
+    }()
+    /**
+     * Fetch Team link icons
+     */
+  }, {
+    key: "getTeamLinkIcons",
+    value: (function () {
+      var _getTeamLinkIcons = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee49() {
+        var _this51 = this;
+        var _len39,
+          args,
+          _key39,
+          _args49 = arguments;
+        return _regeneratorRuntime.wrap(function _callee49$(_context49) {
+          while (1) switch (_context49.prev = _context49.next) {
+            case 0:
+              for (_len39 = _args49.length, args = new Array(_len39), _key39 = 0; _key39 < _len39; _key39++) {
+                args[_key39] = _args49[_key39];
+              }
+              return _context49.abrupt("return", this.measurePerformance('getTeamLinkIcons', function () {
+                var _this51$_objectResolv;
+                return (_this51$_objectResolv = _this51._objectResolverClient).getTeamLinkIcons.apply(_this51$_objectResolv, args);
+              }));
+            case 2:
+            case "end":
+              return _context49.stop();
+          }
+        }, _callee49, this);
+      }));
+      function getTeamLinkIcons() {
+        return _getTeamLinkIcons.apply(this, arguments);
+      }
+      return getTeamLinkIcons;
+    }()
+    /**
+     * Fetch team in slack details
+     */
+    )
+  }, {
+    key: "getTeamInSlack",
+    value: (function () {
+      var _getTeamInSlack = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee50() {
+        var _this52 = this;
+        var _len40,
+          args,
+          _key40,
+          _args50 = arguments;
+        return _regeneratorRuntime.wrap(function _callee50$(_context50) {
+          while (1) switch (_context50.prev = _context50.next) {
+            case 0:
+              for (_len40 = _args50.length, args = new Array(_len40), _key40 = 0; _key40 < _len40; _key40++) {
+                args[_key40] = _args50[_key40];
+              }
+              return _context50.abrupt("return", this.measurePerformance('getTeamInSlack', function () {
+                var _this52$_teamsInSlack;
+                return (_this52$_teamsInSlack = _this52._teamsInSlackClient).getTeamInSlack.apply(_this52$_teamsInSlack, args);
+              }));
+            case 2:
+            case "end":
+              return _context50.stop();
+          }
+        }, _callee50, this);
+      }));
+      function getTeamInSlack() {
+        return _getTeamInSlack.apply(this, arguments);
+      }
+      return getTeamInSlack;
+    }()
+    /**
+     * Delete team in slack
+     */
+    )
+  }, {
+    key: "disconnectTeamInSlack",
+    value: (function () {
+      var _disconnectTeamInSlack = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee51() {
+        var _this53 = this;
+        var _len41,
+          args,
+          _key41,
+          _args51 = arguments;
+        return _regeneratorRuntime.wrap(function _callee51$(_context51) {
+          while (1) switch (_context51.prev = _context51.next) {
+            case 0:
+              for (_len41 = _args51.length, args = new Array(_len41), _key41 = 0; _key41 < _len41; _key41++) {
+                args[_key41] = _args51[_key41];
+              }
+              return _context51.abrupt("return", this.measurePerformance('disconnectTeamInSlack', function () {
+                var _this53$_teamsInSlack;
+                return (_this53$_teamsInSlack = _this53._teamsInSlackClient).disconnectTeamInSlack.apply(_this53$_teamsInSlack, args);
+              }));
+            case 2:
+            case "end":
+              return _context51.stop();
+          }
+        }, _callee51, this);
+      }));
+      function disconnectTeamInSlack() {
+        return _disconnectTeamInSlack.apply(this, arguments);
+      }
+      return disconnectTeamInSlack;
+    }()
+    /**
+     * Update team in slack
+     */
+    )
+  }, {
+    key: "updateTeamInSlack",
+    value: (function () {
+      var _updateTeamInSlack = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee52() {
+        var _this54 = this;
+        var _len42,
+          args,
+          _key42,
+          _args52 = arguments;
+        return _regeneratorRuntime.wrap(function _callee52$(_context52) {
+          while (1) switch (_context52.prev = _context52.next) {
+            case 0:
+              for (_len42 = _args52.length, args = new Array(_len42), _key42 = 0; _key42 < _len42; _key42++) {
+                args[_key42] = _args52[_key42];
+              }
+              return _context52.abrupt("return", this.measurePerformance('updateTeamInSlack', function () {
+                var _this54$_teamsInSlack;
+                return (_this54$_teamsInSlack = _this54._teamsInSlackClient).updateTeamInSlack.apply(_this54$_teamsInSlack, args);
+              }));
+            case 2:
+            case "end":
+              return _context52.stop();
+          }
+        }, _callee52, this);
+      }));
+      function updateTeamInSlack() {
+        return _updateTeamInSlack.apply(this, arguments);
+      }
+      return updateTeamInSlack;
+    }()
+    /**
+     * Update user details
+     */
+    )
+  }, {
+    key: "updateUser",
+    value: (function () {
+      var _updateUser = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee53() {
+        var _this55 = this;
+        var _len43,
+          args,
+          _key43,
+          _args53 = arguments;
+        return _regeneratorRuntime.wrap(function _callee53$(_context53) {
+          while (1) switch (_context53.prev = _context53.next) {
+            case 0:
+              for (_len43 = _args53.length, args = new Array(_len43), _key43 = 0; _key43 < _len43; _key43++) {
+                args[_key43] = _args53[_key43];
+              }
+              return _context53.abrupt("return", this.measurePerformance('updateUser', function () {
+                var _this55$_identityClie;
+                return (_this55$_identityClie = _this55._identityClient).updateUser.apply(_this55$_identityClie, args);
+              }));
+            case 2:
+            case "end":
+              return _context53.stop();
+          }
+        }, _callee53, this);
+      }));
+      function updateUser() {
+        return _updateUser.apply(this, arguments);
+      }
+      return updateUser;
+    }())
+  }, {
+    key: "updateUserAvatar",
+    value: function () {
+      var _updateUserAvatar = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee54() {
+        var _this56 = this;
+        var _len44,
+          args,
+          _key44,
+          _args54 = arguments;
+        return _regeneratorRuntime.wrap(function _callee54$(_context54) {
+          while (1) switch (_context54.prev = _context54.next) {
+            case 0:
+              for (_len44 = _args54.length, args = new Array(_len44), _key44 = 0; _key44 < _len44; _key44++) {
+                args[_key44] = _args54[_key44];
+              }
+              return _context54.abrupt("return", this.measurePerformance('updateUserAvatar', function () {
+                var _this56$_identityClie;
+                return (_this56$_identityClie = _this56._identityClient).updateUserAvatar.apply(_this56$_identityClie, args);
+              }));
+            case 2:
+            case "end":
+              return _context54.stop();
+          }
+        }, _callee54, this);
+      }));
+      function updateUserAvatar() {
+        return _updateUserAvatar.apply(this, arguments);
+      }
+      return updateUserAvatar;
+    }()
+  }]);
+}();
+export var teamsClient = new TeamsClient();