@atlaskit/teams-client 4.0.0

package/dist/es2019/services/public-api-client/index.js

@@ -0,0 +1,120 @@
+import { HttpError, SLOIgnoreHttpError } from '../../common/utils/error';
+import { DEFAULT_CONFIG } from '../constants';
+import { RestClient } from '../rest-client';
+
+/**
+ * @deprecated migrate to generated types
+ */
+
+/**
+ * @deprecated migrate to generated types
+ */
+
+/**
+ * @deprecated migrate to generated types
+ */
+
+const V1_URL = '/teams/v1';
+const SENTRY_IGNORED_ERROR_MESSAGES_CREATE = ['TEAM_NOT_FOUND'];
+export class PublicApiClient extends RestClient {
+  constructor(serviceUrlRoot) {
+    super({
+      serviceUrl: serviceUrlRoot
+    });
+  }
+  async addUsersToTeam(teamId, members) {
+    if (!members || members.length === 0) {
+      const missingMembersError = new Error('Missing members to add');
+      this.logException(missingMembersError, 'addUsersToTeam');
+      throw missingMembersError;
+    }
+    const membersWithIds = members.filter(member => !!member.accountId);
+    if (membersWithIds.length !== members.length) {
+      this.logException(new Error('Missing accountIds for some members'), 'addUsersToTeam');
+    }
+    if (membersWithIds.length === 0) {
+      const missingMembersError = new Error('Missing accountIds for all members');
+      this.logException(missingMembersError, 'addUsersToTeam');
+      throw missingMembersError;
+    }
+    try {
+      const orgId = this.getOrgId();
+      const url = `${V1_URL}/org/${orgId}/teams/${teamId}/members/add`;
+      const response = await this.postResource(url, {
+        members: membersWithIds
+      });
+      return response;
+    } catch (e) {
+      this.logException(e, 'addUsersToTeam');
+      if (e instanceof HttpError && SENTRY_IGNORED_ERROR_MESSAGES_CREATE.includes(e.message)) {
+        throw new SLOIgnoreHttpError(e);
+      }
+      throw e;
+    }
+  }
+  async removeTeamMemberships(teamId, members) {
+    if (!members || members.length === 0) {
+      const missingMembersError = new Error('Missing members to remove');
+      this.logException(missingMembersError, 'removeTeamMemberships');
+      throw missingMembersError;
+    }
+    const membersWithIds = members.filter(member => !!member.accountId);
+    if (membersWithIds.length !== members.length) {
+      this.logException(new Error('Missing accountIds for some members'), 'addUsersToTeam');
+    }
+    if (membersWithIds.length === 0) {
+      const missingMembersError = new Error('Missing accountIds for all members');
+      this.logException(missingMembersError, 'removeTeamMemberships');
+      throw missingMembersError;
+    }
+    try {
+      const orgId = this.getOrgId();
+      const url = `${V1_URL}/org/${orgId}/teams/${teamId}/members/remove`;
+      const response = await this.postResource(url, {
+        members: membersWithIds
+      });
+      return response;
+    } catch (e) {
+      this.logException(e, 'removeTeamMemberships');
+      throw e;
+    }
+  }
+  async getTeamDetails(teamId) {
+    try {
+      const orgId = this.getOrgId();
+      const url = `${V1_URL}/org/${orgId}/teams/${teamId}`;
+      const response = await this.getResource(url);
+      return response;
+    } catch (e) {
+      this.logException(e, 'getTeamDetails');
+      throw e;
+    }
+  }
+  async getTeamMembers(teamId, first = 50, after) {
+    try {
+      const orgId = this.getOrgId();
+      const url = `${V1_URL}/org/${orgId}/teams/${teamId}/members`;
+      const response = await this.postResource(url, {
+        after,
+        first
+      });
+      return response;
+    } catch (e) {
+      this.logException(e, 'getTeamMembers');
+      throw e;
+    }
+  }
+  async restoreTeam(teamId) {
+    try {
+      const orgId = this.getOrgId();
+      const url = `${V1_URL}/org/${orgId}/teams/${teamId}/restore`;
+      return this.postResource(url);
+    } catch (e) {
+      this.logException(e, 'restoreTeam');
+      throw e;
+    }
+  }
+}
+
+// eslint-disable-next-line import/no-anonymous-default-export
+export default new PublicApiClient(DEFAULT_CONFIG.publicApiRoot);

package/dist/es2019/services/rest-client/index.js

@@ -0,0 +1,177 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import once from 'lodash/once';
+import { HttpError, SLOIgnoreError } from '../../common/utils/error';
+import { fetchWithExponentialBackoff } from '../../common/utils/http';
+import { handleResponse } from '../../common/utils/status-code-handlers-provider';
+import { BaseClient } from '../base-client';
+import { clearCookie, getCookieAsInteger, REDIRECT_COUNT, setCookie } from './utils/cookie';
+import { parseErrorMessage } from './utils/parse-error-message';
+import { parseResponse } from './utils/parse-response';
+import { stripUUIDFromPath } from './utils/strip-uuid';
+const defaultFetchOptions = {
+  credentials: 'include',
+  headers: {
+    Accept: 'application/json'
+  },
+  mode: 'cors'
+};
+let incrementRedirectCount;
+let clearRedirectCount;
+resetRedirectCountOnceFlag();
+
+// Used by test to reset the once-ness of the functions above
+export function resetRedirectCountOnceFlag() {
+  incrementRedirectCount = once(() => setCookie(REDIRECT_COUNT, getCookieAsInteger(REDIRECT_COUNT) + 1));
+  clearRedirectCount = once(() => clearCookie(REDIRECT_COUNT));
+}
+export class RestClient extends BaseClient {
+  constructor({
+    serviceUrl = '',
+    config = {
+      logException: () => {}
+    }
+  }) {
+    super(config);
+    /**
+     * This function is necessary for if `statusCodeHandler` prescribes a login
+     * redirect upon a 401 response.
+     * While the default redirect behaviour may be overriden, this function has
+     * been kept separate to ensure it cannot be overriden, lest a host
+     * application supply embeddable-directory with a custom handler that suffers
+     * the infinite redirect bug.
+     */
+    _defineProperty(this, "preventInfiniteRedirectLoop", response => {
+      if (!response.ok) {
+        const responseStatusCode = response.status;
+        if (responseStatusCode === 401) {
+          incrementRedirectCount();
+        }
+      } else {
+        clearRedirectCount();
+      }
+    });
+    this.serviceUrl = serviceUrl;
+  }
+  setServiceUrl(serviceUrl) {
+    this.serviceUrl = serviceUrl;
+  }
+  async getResource(path, fetchOptions = {}) {
+    return this.makeRequest(path, fetchOptions);
+  }
+  async getResourceCached(path, fetchOptions = {}, cacheOptions) {
+    const cacheKey = path;
+    const cacheRecord = this.getCachedValue(cacheKey);
+    if (cacheRecord) {
+      return cacheRecord;
+    }
+    const response = await this.getResource(path, fetchOptions);
+    this.cacheValue(cacheKey, response, cacheOptions === null || cacheOptions === void 0 ? void 0 : cacheOptions.expiration);
+    return response;
+  }
+  async postResource(path, data, fetchOptions = {}) {
+    return this.postResourceRaw(path, JSON.stringify(data), fetchOptions);
+  }
+  async postResourceRaw(path, data, fetchOptions = {}) {
+    fetchOptions = {
+      method: 'post',
+      headers: {},
+      ...fetchOptions
+    };
+    if (data) {
+      fetchOptions = {
+        body: data,
+        ...fetchOptions,
+        headers: {
+          'Content-Type': 'application/json',
+          ...fetchOptions.headers
+        }
+      };
+    }
+    return this.makeRequest(path, fetchOptions);
+  }
+  async patchResource(path, data) {
+    let fetchOptions = {
+      /**
+       * PATCH must be uppercase as per fetch spec only
+       * DELETE, GET, HEAD, OPTIONS, POST, and PUT methods
+       * are normalised to uppercase.
+       *
+       * https://github.com/github/fetch/issues/37
+       * https://fetch.spec.whatwg.org/#methods
+       */
+      method: 'PATCH'
+    };
+    if (data) {
+      fetchOptions = {
+        ...fetchOptions,
+        body: JSON.stringify(data),
+        headers: {
+          'Content-Type': 'application/json'
+        }
+      };
+    }
+    return this.makeRequest(path, fetchOptions);
+  }
+  async putResource(path, data, additionalFetchOptions = {}) {
+    const fetchOptions = {
+      method: 'put'
+    };
+    if (data) {
+      Object.assign(fetchOptions, {
+        body: JSON.stringify(data),
+        headers: {
+          'Content-Type': 'application/json'
+        }
+      });
+    }
+    return this.makeRequest(path, {
+      ...fetchOptions,
+      ...additionalFetchOptions
+    });
+  }
+  async deleteResource(path, options = {}) {
+    const fetchOptions = {
+      ...options,
+      method: 'delete'
+    };
+    return this.makeRequest(path, fetchOptions);
+  }
+  async makeRequest(path, additionalFetchOptions = {
+    shouldLogError: e => e.status !== 429
+  }) {
+    const url = this.serviceUrl + path;
+    const options = {
+      ...defaultFetchOptions,
+      ...additionalFetchOptions
+    };
+    const response = await fetchWithExponentialBackoff(url, options);
+    this.preventInfiniteRedirectLoop(response);
+    handleResponse(response);
+    const responseStatusCode = response.status;
+    const traceId = response.headers.get('atl-traceid');
+    if (!response.ok) {
+      if (responseStatusCode === 401) {
+        throw new SLOIgnoreError({
+          message: 'Unauthorized Request - incrementing redirect count'
+        });
+      } else {
+        const message = await parseErrorMessage(response);
+        const httpError = new HttpError({
+          message,
+          status: responseStatusCode,
+          traceId: traceId !== null && traceId !== void 0 ? traceId : undefined,
+          path
+        });
+        if (options.shouldLogError && options.shouldLogError(httpError)) {
+          this.logException(httpError, stripUUIDFromPath(path), {
+            method: options.method || 'GET',
+            url,
+            status: responseStatusCode
+          });
+        }
+        throw httpError;
+      }
+    }
+    return additionalFetchOptions.ignoreResponse ? null : parseResponse(response);
+  }
+}

package/dist/es2019/services/rest-client/utils/cookie.js

@@ -0,0 +1,13 @@
+export const REDIRECT_COUNT = 'redirectCount';
+export const IDENTITY_CSRF_TOKEN = 'avatar.csrf.token';
+export function setCookie(key, value) {
+  document.cookie = `${key}=${value};path=/;max-age=30`;
+}
+export function getCookieAsInteger(key, defaultValue = 0) {
+  const regex = new RegExp(`${key}=(\\d+)`);
+  const result = document.cookie.match(regex);
+  return result ? parseInt(result[1], 10) : defaultValue;
+}
+export function clearCookie(key) {
+  document.cookie = `${key}=doesntmatter;path=/;expires=Thu, 01 Jan 1970 00:00:01 GMT`;
+}

package/dist/es2019/services/rest-client/utils/parse-error-message.js

@@ -0,0 +1,20 @@
+export async function parseErrorMessage(response) {
+  let json;
+  const text = await response.text();
+  try {
+    json = JSON.parse(text);
+  } catch (err) {
+    return text;
+  }
+  delete json.timestamp; // to dedupe sentry, scrub non-unique 'timestamp' field from the error body
+
+  if (json.error) {
+    return `${json.status || 'UNKNOWN_STATUS'} ${json.error || 'MISSING_ERROR_MESSAGE'}`;
+  } else if (json.status) {
+    return `${json.status} MISSING_ERROR_MESSAGE`;
+  } else if (json.errors) {
+    const errs = json.errors.map(error => typeof error === 'string' ? error : error.code || error.message || 'MISSING_ERROR_MESSAGE');
+    return errs.join('\n - ');
+  }
+  return JSON.stringify(json);
+}

package/dist/es2019/services/rest-client/utils/parse-response.js

@@ -0,0 +1,14 @@
+export function parseResponse(response) {
+  const responseStatusCode = response.status;
+  if (responseStatusCode === 204 || responseStatusCode === 202) {
+    return null;
+  }
+  const contentType = response.headers.get('content-type');
+  if (!contentType || contentType.includes('text/html') || contentType.includes('text/plain')) {
+    return response.text();
+  }
+  if (contentType.includes('application/json')) {
+    return response.json();
+  }
+  return null;
+}

package/dist/es2019/services/rest-client/utils/strip-uuid.js

@@ -0,0 +1,4 @@
+const UUID_REGEX = new RegExp(/((\w{4,12}-?)){5}/g);
+export const stripUUIDFromPath = path => {
+  return path.replace(UUID_REGEX, '<UUID>');
+};

package/dist/es2019/services/sentry/constants.js

@@ -0,0 +1,10 @@
+import { isFedRamp } from '@atlaskit/atlassian-context';
+
+// https://sentry.io/settings/atlassian-2y/projects/people-and-teams-directory/keys/
+export const SENTRY_PUBLIC_KEY = '1dc056d49dfe4df8961dc1b810e4620d';
+export const SENTRY_PROJECT_ID = '5988845';
+export const SENTRY_FEDRAMP_PUBLIC_KEY = '067abcc494be9a87b3cdf9416f2b97d5';
+export const SENTRY_FEDRAMP_PROJECT_ID = '47';
+const SENTRY_COMMERCIAL_DSN = `https://${SENTRY_PUBLIC_KEY}@o55978.ingest.sentry.io/${SENTRY_PROJECT_ID}`;
+const SENTRY_FEDRAMP_DSN = `https://${SENTRY_FEDRAMP_PUBLIC_KEY}@sentry.atlassian-us-gov-mod.com/${SENTRY_FEDRAMP_PROJECT_ID}`;
+export const SENTRY_DSN = isFedRamp() ? SENTRY_FEDRAMP_DSN : SENTRY_COMMERCIAL_DSN;

package/dist/es2019/services/sentry/index.js

@@ -0,0 +1,2 @@
+export { addBreadcrumb, logException, logErrorMessage, logInfoMessage, createErrorHandler, logExceptionWithPackageContext, logErrorMessageWithPackageContext, logInfoMessageWithPackageContext, createErrorHandlerWithPackageContext } from './main';
+export { useTeamsSentryClientSetup } from './utils/use-teams-sentry-client-setup';

package/dist/es2019/services/sentry/main.js

@@ -0,0 +1,107 @@
+// See Sentry accepted options in here https://docs.sentry.io/error-reporting/configuration/?platform=javascript
+
+// eslint-disable-next-line import/no-extraneous-dependencies
+
+import { getSentryClient } from './utils/sentry-client';
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+
+function decorateScope(scope, context) {
+  const {
+    tags,
+    ...otherContext
+  } = context;
+  if (tags) {
+    scope.setTags(tags);
+  }
+  if (Object.keys(otherContext).length) {
+    scope.setExtras(otherContext);
+  }
+  return scope;
+}
+export async function logException(ex, name, context = {}) {
+  try {
+    const sentryClient = await getSentryClient();
+    if (!sentryClient || typeof sentryClient.captureException !== 'function') {
+      return;
+    }
+    sentryClient.withScope(scope => {
+      var _context$packageName, _context$packageVersi;
+      decorateScope(scope, context);
+      scope.setTag('name', name);
+      scope.setTag('packageName', (_context$packageName = context.packageName) !== null && _context$packageName !== void 0 ? _context$packageName : 'unknown');
+      scope.setTag('packageVersion', (_context$packageVersi = context.packageVersion) !== null && _context$packageVersi !== void 0 ? _context$packageVersi : 'unknown');
+      sentryClient.captureException(ex, scope);
+    });
+  } catch {
+    // silence sentry exceptions
+  }
+}
+async function logMessage(severity, message, context = {}) {
+  const sentryClient = await getSentryClient();
+  if (!sentryClient || typeof sentryClient.captureException !== 'function') {
+    return;
+  }
+  sentryClient.withScope(scope => {
+    var _context$packageName2, _context$packageVersi2;
+    decorateScope(scope, context);
+    // The Severity enum is being replaced by SeverityLevel type in v7 anyway
+    scope.setLevel(severity);
+    scope.setTag('packageName', (_context$packageName2 = context.packageName) !== null && _context$packageName2 !== void 0 ? _context$packageName2 : 'unknown');
+    scope.setTag('packageVersion', (_context$packageVersi2 = context.packageVersion) !== null && _context$packageVersi2 !== void 0 ? _context$packageVersi2 : 'unknown');
+    sentryClient.captureMessage(message, scope);
+  });
+}
+export function logErrorMessage(message, context = {}) {
+  logMessage('error', message, context).catch(() => {});
+}
+export function logInfoMessage(message, context = {}) {
+  logMessage('info', message, context).catch(() => {});
+}
+export const createErrorHandler = details => {
+  return (error, message, tags = {}) => {
+    logException(error, message, {
+      tags: {
+        ...details,
+        ...tags
+      }
+    });
+  };
+};
+export const logExceptionWithPackageContext = packageContext => (...args) => {
+  // Intentionally not awaiting the promise here as we don't need the result
+  logException(args[0], args[1], {
+    ...args[2],
+    packageName: packageContext.packageName,
+    packageVersion: packageContext.packageVersion
+  });
+};
+export const logErrorMessageWithPackageContext = packageContext => (...args) => {
+  // Intentionally not awaiting the promise here as we don't need the result
+  logErrorMessage(args[0], {
+    ...args[1],
+    packageName: packageContext.packageName,
+    packageVersion: packageContext.packageVersion
+  });
+};
+export const logInfoMessageWithPackageContext = packageContext => (...args) => {
+  // Intentionally not awaiting the promise here as we don't need the result
+  logInfoMessage(args[0], {
+    ...args[1],
+    packageName: packageContext.packageName,
+    packageVersion: packageContext.packageVersion
+  });
+};
+export const createErrorHandlerWithPackageContext = packageContext => (...args) => createErrorHandler({
+  ...args[0],
+  packageName: packageContext.packageName,
+  packageVersion: packageContext.packageVersion
+});
+export async function addBreadcrumb(crumb) {
+  const sentryClient = await getSentryClient();
+  sentryClient.withScope(scope => {
+    scope.addBreadcrumb(typeof crumb === 'string' ? {
+      message: crumb
+    } : crumb);
+  });
+}

package/dist/es2019/services/sentry/types.js

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

package/dist/es2019/services/sentry/utils/get-sentry-config.js

@@ -0,0 +1,37 @@
+import { SENTRY_DSN } from '../constants';
+const DEFAULT_SENTRY_CONFIG = {
+  whitelistUrls: [/atl-paas.net/,
+  // test local host
+  /localhost/],
+  ignoreErrors: [/^SentryIgnore:/,
+  // Network related errors
+  'The operation was aborted', 'Software caused connection abort', 'GraphQL error: Failed to fetch', 'TypeError: Failed to fetch', 'TypeError: NetworkError when attempting to fetch resource.', 'AbortError: The user aborted a request.', /^network error/i, /^network failure/i, /^NetworkError/i, /^Unexpected token ..*/],
+  ignoreUrls: [
+  // Chrome extensions
+  /extensions\//i, /^chrome:\/\//i],
+  dsn: SENTRY_DSN,
+  attachStacktrace: true
+};
+
+// return value is an Sentry configuration object:
+// https://docs.sentry.io/learn/configuration/?platform=javascript
+export function getSentryConfig(options) {
+  var _window$__buildInfo;
+  const {
+    env,
+    version,
+    noGlobals: _,
+    ...otherOptions
+  } = options;
+  return {
+    ...otherOptions,
+    ...DEFAULT_SENTRY_CONFIG,
+    // Standalone __VERSION__ is set from `bin/set-release-version.sh`
+    // when building to deploy to production
+    release: `${"@atlaskit/teams-client"}@${"4.0.0"}` ||
+    // @ts-ignore Jira  - window.BUILD_KEY
+    window.BUILD_KEY || ( // @ts-ignore Confluence - window.__buildInfo
+    (_window$__buildInfo = window.__buildInfo) === null || _window$__buildInfo === void 0 ? void 0 : _window$__buildInfo.FRONTEND_VERSION) || '---',
+    environment: env || 'prod'
+  };
+}

package/dist/es2019/services/sentry/utils/initialise-sentry.js

@@ -0,0 +1,23 @@
+import { getSentryConfig } from './get-sentry-config';
+import { sentryClient, setSentryClient } from './sentry-client';
+const DISABLED_INTEGRATIONS = ['onerror', 'onunhandledrejection',
+// In Jira this integration is being initialised twice, resulting in no events being sent to Sentry
+'Dedupe'];
+export async function initialiseSentry(client, options) {
+  if (sentryClient) {
+    return;
+  }
+  if (!client) {
+    return;
+  }
+  setSentryClient(client);
+  const sentryConfig = getSentryConfig(options);
+  sentryClient.init({
+    ...sentryConfig,
+    integrations: function (integrations) {
+      return integrations.filter(function (integration) {
+        return DISABLED_INTEGRATIONS.indexOf(integration.name) === -1;
+      });
+    }
+  });
+}

package/dist/es2019/services/sentry/utils/sentry-client.js

@@ -0,0 +1,57 @@
+import { SENTRY_DSN } from '../constants';
+import { initialiseSentry } from './initialise-sentry';
+export let sentryClient;
+export const setSentryClient = client => {
+  sentryClient = client;
+};
+export const getSentryClient = async () => {
+  if (!sentryClient) {
+    await setupSentryClient({});
+  }
+  return sentryClient;
+};
+export async function setupSentryClient({
+  appName,
+  env
+}) {
+  var _window$__buildInfo;
+  const sentryClient = await requireSentryLib();
+  if (!sentryClient) {
+    return;
+  }
+
+  // initialiseSentry sets the sentry client
+  initialiseSentry(sentryClient, {
+    initialScope: {
+      tags: {
+        renderMode: appName || 'unknown',
+        productBuild:
+        // @ts-ignore Jira  - window.BUILD_KEY, confluence - window.__buildInfo
+        window.BUILD_KEY || ((_window$__buildInfo = window.__buildInfo) === null || _window$__buildInfo === void 0 ? void 0 : _window$__buildInfo.FRONTEND_VERSION) || 'unknown',
+        product: getProduct()
+      }
+    },
+    env,
+    noGlobals: true,
+    dsn: SENTRY_DSN,
+    attachStacktrace: true
+  });
+}
+async function requireSentryLib() {
+  // saving ~40K
+  try {
+    return import( /* webpackChunkName: "teams-client_sentry" */'@sentry/browser');
+  } catch (error) {
+    // eslint-disable-next-line no-console
+    console.warn('Ignoring rejected promise when loading sentry resource.', error);
+  }
+}
+function getProduct() {
+  const path = window.location.pathname;
+  if (path.includes('/jira/people')) {
+    return 'jira';
+  } else if (path.includes('/wiki/people')) {
+    return 'confluence';
+  }
+  return 'unknown';
+}

package/dist/es2019/services/sentry/utils/use-teams-sentry-client-setup.js

@@ -0,0 +1,14 @@
+import { useCallback, useEffect, useState } from 'react';
+import { sentryClient, setupSentryClient } from './sentry-client';
+export const useTeamsSentryClientSetup = (isSentryEnabled, config) => {
+  const [sentryInitialised, setSentryInitialised] = useState(false);
+  const setupSentry = useCallback(async () => {
+    if (!sentryInitialised && isSentryEnabled && !sentryClient) {
+      await setupSentryClient(config);
+    }
+  }, [config, isSentryEnabled, sentryInitialised]);
+  useEffect(() => {
+    setupSentry().then(() => setSentryInitialised(true));
+  }, [setupSentry]);
+  return sentryClient;
+};

package/dist/es2019/services/teams-in-slack-client/index.js

@@ -0,0 +1,32 @@
+import { DEFAULT_CONFIG } from '../constants';
+import { RestClient } from '../rest-client';
+const defaultConfig = {
+  serviceUrl: `${DEFAULT_CONFIG.stargateRoot}/teamsslack/api/team`
+};
+export class TeamsInSlackClient extends RestClient {
+  constructor(config = {}) {
+    super({
+      ...defaultConfig,
+      ...config
+    });
+  }
+  async getTeamInSlack(teamId, teamName) {
+    return this.getResource(`/${teamId}?teamName=${encodeURIComponent(teamName)}`).then(response => ({
+      id: teamId,
+      ...response
+    }));
+  }
+  async disconnectTeamInSlack(teamId) {
+    return this.deleteResource(`/${teamId}`).then(response => ({
+      id: teamId,
+      ...response
+    }));
+  }
+  async updateTeamInSlack(teamId, channelId, usergroupHandle) {
+    return this.postResource(`/${teamId}?channel=${channelId}&groupName=${usergroupHandle}`).then(response => ({
+      id: teamId,
+      ...response
+    }));
+  }
+}
+export default new TeamsInSlackClient();

package/dist/es2019/services/use-query-light/index.js

@@ -0,0 +1,2 @@
+export { useQueryLight, useLazyQueryLight } from './main';
+export { UseQueryLightError } from './types';