@atlaskit/mention 21.0.7 → 21.0.9

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @atlaskit/mention
 
+## 21.0.9
+
+### Patch Changes
+
+- [`016d3039482`](https://bitbucket.org/atlassian/atlassian-frontend/commits/016d3039482) - Updates `@emotion/core` v10 to `@emotion/react` v11. There is no expected behavior change.
+
+## 21.0.8
+
+### Patch Changes
+
+- [`8cc2f888c83`](https://bitbucket.org/atlassian/atlassian-frontend/commits/8cc2f888c83) - Upgrade Typescript from `4.3.5` to `4.5.5`
+
 ## 21.0.7
 
 ### Patch Changes

package/_constants/package.json

@@ -4,5 +4,12 @@
   "module": "../dist/esm/_constants.js",
   "module:es2019": "../dist/es2019/_constants.js",
   "sideEffects": false,
-  "types": "../dist/types/_constants.d.ts"
+  "types": "../dist/types/_constants.d.ts",
+  "typesVersions": {
+    ">=4.0 <4.5": {
+      "*": [
+        "../dist/types-ts4.0/_constants.d.ts"
+      ]
+    }
+  }
 }

package/dist/cjs/components/Mention/PrimitiveMention.js

@@ -15,7 +15,7 @@ var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/h
 
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 
-var _core = require("@emotion/core");
+var _react = require("@emotion/react");
 
 var _components = require("@atlaskit/theme/components");
 
@@ -25,7 +25,7 @@ var _tokens = require("@atlaskit/tokens");
 
 var _types = require("../../types");
 
-var _react = require("react");
+var _react2 = require("react");
 
 var _excluded = ["mentionType"];
 
@@ -90,13 +90,13 @@ var getStyle = function getStyle(_ref, property) {
   });
 };
 
-var PrimitiveMention = /*#__PURE__*/(0, _react.forwardRef)(function (_ref2, ref) {
+var PrimitiveMention = /*#__PURE__*/(0, _react2.forwardRef)(function (_ref2, ref) {
   var mentionType = _ref2.mentionType,
       other = (0, _objectWithoutProperties2.default)(_ref2, _excluded);
   var theme = (0, _components.useGlobalTheme)();
-  return (0, _core.jsx)("span", (0, _extends2.default)({
+  return (0, _react.jsx)("span", (0, _extends2.default)({
     ref: ref,
-    css: (0, _core.css)(_templateObject || (_templateObject = (0, _taggedTemplateLiteral2.default)(["\n          display: inline;\n          border: 1px solid ", ";\n          background: ", ";\n          color: ", ";\n          border-radius: 20px;\n          cursor: pointer;\n          padding: 0 0.3em 2px 0.23em;\n          line-height: 1.714;\n          font-size: 1em;\n          font-weight: normal;\n          word-break: break-word;\n          &:hover {\n            background: ", ";\n          }\n          &:active {\n            background: ", ";\n          }\n        "])), getStyle({
+    css: (0, _react.css)(_templateObject || (_templateObject = (0, _taggedTemplateLiteral2.default)(["\n          display: inline;\n          border: 1px solid ", ";\n          background: ", ";\n          color: ", ";\n          border-radius: 20px;\n          cursor: pointer;\n          padding: 0 0.3em 2px 0.23em;\n          line-height: 1.714;\n          font-size: 1em;\n          font-weight: normal;\n          word-break: break-word;\n          &:hover {\n            background: ", ";\n          }\n          &:active {\n            background: ", ";\n          }\n        "])), getStyle({
       theme: theme,
       mentionType: mentionType
     }, 'borderColor'), getStyle({

package/dist/cjs/version.json

@@ -1,5 +1,5 @@
 {
 	"name": "@atlaskit/mention",
-	"version": "21.0.7",
+	"version": "21.0.9",
 	"sideEffects": false
 }

package/dist/es2019/components/Mention/PrimitiveMention.js

@@ -1,7 +1,7 @@
 import _extends from "@babel/runtime/helpers/extends";
 
 /** @jsx jsx */
-import { jsx, css } from '@emotion/core';
+import { jsx, css } from '@emotion/react';
 import { themed, useGlobalTheme } from '@atlaskit/theme/components';
 import { B400, B200, N500, DN800, DN100, DN80, N30A, DN30, N20 } from '@atlaskit/theme/colors';
 import { token } from '@atlaskit/tokens';

package/dist/es2019/version.json

@@ -1,5 +1,5 @@
 {
 	"name": "@atlaskit/mention",
-	"version": "21.0.7",
+	"version": "21.0.9",
 	"sideEffects": false
 }

package/dist/esm/components/Mention/PrimitiveMention.js

@@ -7,7 +7,7 @@ var _excluded = ["mentionType"];
 var _mentionStyle, _templateObject;
 
 /** @jsx jsx */
-import { jsx, css } from '@emotion/core';
+import { jsx, css } from '@emotion/react';
 import { themed, useGlobalTheme } from '@atlaskit/theme/components';
 import { B400, B200, N500, DN800, DN100, DN80, N30A, DN30, N20 } from '@atlaskit/theme/colors';
 import { token } from '@atlaskit/tokens';

package/dist/esm/version.json

@@ -1,5 +1,5 @@
 {
 	"name": "@atlaskit/mention",
-	"version": "21.0.7",
+	"version": "21.0.9",
 	"sideEffects": false
 }

package/dist/types/api/ContextMentionResource.d.ts

@@ -12,8 +12,8 @@ export default class ContextMentionResource implements MentionProvider {
     private contextIdentifier;
     constructor(mentionProvider: MentionProvider, contextIdentifier: MentionContextIdentifier);
     getContextIdentifier(): MentionContextIdentifier | undefined;
-    callWithContextIds: <K extends "filter" | "recordMentionSelection" | "shouldHighlightMention" | "isFiltering" | "subscribe" | "unsubscribe">(f: K, declaredArgs: number) => MentionProvider[K];
-    callDefault: <K extends "filter" | "recordMentionSelection" | "shouldHighlightMention" | "isFiltering" | "subscribe" | "unsubscribe">(f: K) => MentionProvider[K];
+    callWithContextIds: <K extends "subscribe" | "unsubscribe" | "filter" | "recordMentionSelection" | "shouldHighlightMention" | "isFiltering">(f: K, declaredArgs: number) => MentionProvider[K];
+    callDefault: <K extends "subscribe" | "unsubscribe" | "filter" | "recordMentionSelection" | "shouldHighlightMention" | "isFiltering">(f: K) => MentionProvider[K];
     subscribe: (key: string, callback?: ResultCallback<MentionDescription[]> | undefined, errCallback?: ErrorCallback | undefined, infoCallback?: InfoCallback | undefined, allResultsCallback?: ResultCallback<MentionDescription[]> | undefined, analyticsCallback?: import("../types").AnalyticsCallback | undefined) => void;
     unsubscribe: (key: string) => void;
     filter: (query?: string | undefined, contextIdentifier?: MentionContextIdentifier | undefined) => void;

package/dist/types/components/MentionDescriptionByline/styles.d.ts

@@ -1,2 +1,5 @@
 /// <reference types="react" />
-export declare const DescriptionBylineStyle: import("@emotion/styled-base").StyledComponent<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, Pick<import("react").ClassAttributes<HTMLSpanElement> & import("react").HTMLAttributes<HTMLSpanElement>, keyof import("react").HTMLAttributes<HTMLSpanElement>>, object>;
+export declare const DescriptionBylineStyle: import("@emotion/styled").StyledComponent<{
+    theme?: import("@emotion/react").Theme | undefined;
+    as?: import("react").ElementType<any> | undefined;
+}, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, {}>;

package/dist/types/components/MentionItem/styles.d.ts

@@ -11,12 +11,36 @@ export interface NameSectionStyleProps {
 export interface InfoSectionStyleProps {
     restricted?: boolean;
 }
-export declare const RowStyle: import("@emotion/styled-base").StyledComponent<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, Pick<import("react").ClassAttributes<HTMLDivElement> & import("react").HTMLAttributes<HTMLDivElement>, keyof import("react").HTMLAttributes<HTMLDivElement>>, object>;
-export declare const AvatarStyle: import("@emotion/styled-base").StyledComponent<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, AvatarSectionStyleProps, object>;
-export declare const NameSectionStyle: import("@emotion/styled-base").StyledComponent<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, NameSectionStyleProps, object>;
-export declare const FullNameStyle: import("@emotion/styled-base").StyledComponent<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, Pick<import("react").ClassAttributes<HTMLSpanElement> & import("react").HTMLAttributes<HTMLSpanElement>, keyof import("react").HTMLAttributes<HTMLSpanElement>>, object>;
-export declare const InfoSectionStyle: import("@emotion/styled-base").StyledComponent<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, InfoSectionStyleProps, object>;
-export declare const TimeStyle: import("@emotion/styled-base").StyledComponent<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, Pick<import("react").ClassAttributes<HTMLDivElement> & import("react").HTMLAttributes<HTMLDivElement>, keyof import("react").HTMLAttributes<HTMLDivElement>>, object>;
+export declare const RowStyle: import("@emotion/styled").StyledComponent<{
+    theme?: import("@emotion/react").Theme | undefined;
+    as?: import("react").ElementType<any> | undefined;
+}, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
+export declare const AvatarStyle: import("@emotion/styled").StyledComponent<{
+    theme?: import("@emotion/react").Theme | undefined;
+    as?: import("react").ElementType<any> | undefined;
+} & AvatarSectionStyleProps, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, {}>;
+export declare const NameSectionStyle: import("@emotion/styled").StyledComponent<{
+    theme?: import("@emotion/react").Theme | undefined;
+    as?: import("react").ElementType<any> | undefined;
+} & NameSectionStyleProps, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
+export declare const FullNameStyle: import("@emotion/styled").StyledComponent<{
+    theme?: import("@emotion/react").Theme | undefined;
+    as?: import("react").ElementType<any> | undefined;
+}, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, {}>;
+export declare const InfoSectionStyle: import("@emotion/styled").StyledComponent<{
+    theme?: import("@emotion/react").Theme | undefined;
+    as?: import("react").ElementType<any> | undefined;
+} & InfoSectionStyleProps, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
+export declare const TimeStyle: import("@emotion/styled").StyledComponent<{
+    theme?: import("@emotion/react").Theme | undefined;
+    as?: import("react").ElementType<any> | undefined;
+}, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
 export declare const MENTION_ITEM_HEIGHT = 48;
-export declare const MentionItemStyle: import("@emotion/styled-base").StyledComponent<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, MentionItemStyleProps, object>;
-export declare const AccessSectionStyle: import("@emotion/styled-base").StyledComponent<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, Pick<import("react").ClassAttributes<HTMLDivElement> & import("react").HTMLAttributes<HTMLDivElement>, keyof import("react").HTMLAttributes<HTMLDivElement>>, object>;
+export declare const MentionItemStyle: import("@emotion/styled").StyledComponent<{
+    theme?: import("@emotion/react").Theme | undefined;
+    as?: import("react").ElementType<any> | undefined;
+} & MentionItemStyleProps, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
+export declare const AccessSectionStyle: import("@emotion/styled").StyledComponent<{
+    theme?: import("@emotion/react").Theme | undefined;
+    as?: import("react").ElementType<any> | undefined;
+}, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;

package/dist/types/components/MentionList/styles.d.ts

@@ -2,4 +2,7 @@
 export interface MentionListStyleProps {
     empty?: boolean;
 }
-export declare const MentionListStyle: import("@emotion/styled-base").StyledComponent<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, MentionListStyleProps, object>;
+export declare const MentionListStyle: import("@emotion/styled").StyledComponent<{
+    theme?: import("@emotion/react").Theme | undefined;
+    as?: import("react").ElementType<any> | undefined;
+} & MentionListStyleProps, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;

package/dist/types/components/MentionListError/styles.d.ts

@@ -1,5 +1,17 @@
 /// <reference types="react" />
-export declare const MentionListErrorStyle: import("@emotion/styled-base").StyledComponent<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, Pick<import("react").ClassAttributes<HTMLDivElement> & import("react").HTMLAttributes<HTMLDivElement>, keyof import("react").HTMLAttributes<HTMLDivElement>>, object>;
-export declare const GenericErrorVisualStyle: import("@emotion/styled-base").StyledComponent<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, Pick<import("react").ClassAttributes<HTMLDivElement> & import("react").HTMLAttributes<HTMLDivElement>, keyof import("react").HTMLAttributes<HTMLDivElement>>, object>;
-export declare const MentionListErrorHeadlineStyle: import("@emotion/styled-base").StyledComponent<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, Pick<import("react").ClassAttributes<HTMLDivElement> & import("react").HTMLAttributes<HTMLDivElement>, keyof import("react").HTMLAttributes<HTMLDivElement>>, object>;
-export declare const MentionListAdviceStyle: import("@emotion/styled-base").StyledComponent<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, Pick<import("react").ClassAttributes<HTMLDivElement> & import("react").HTMLAttributes<HTMLDivElement>, keyof import("react").HTMLAttributes<HTMLDivElement>>, object>;
+export declare const MentionListErrorStyle: import("@emotion/styled").StyledComponent<{
+    theme?: import("@emotion/react").Theme | undefined;
+    as?: import("react").ElementType<any> | undefined;
+}, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
+export declare const GenericErrorVisualStyle: import("@emotion/styled").StyledComponent<{
+    theme?: import("@emotion/react").Theme | undefined;
+    as?: import("react").ElementType<any> | undefined;
+}, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
+export declare const MentionListErrorHeadlineStyle: import("@emotion/styled").StyledComponent<{
+    theme?: import("@emotion/react").Theme | undefined;
+    as?: import("react").ElementType<any> | undefined;
+}, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
+export declare const MentionListAdviceStyle: import("@emotion/styled").StyledComponent<{
+    theme?: import("@emotion/react").Theme | undefined;
+    as?: import("react").ElementType<any> | undefined;
+}, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;

package/dist/types/components/MentionPicker/styles.d.ts

@@ -2,5 +2,11 @@
 export interface MentionPickerStyleProps {
     visible?: boolean | string;
 }
-export declare const MentionPickerStyle: import("@emotion/styled-base").StyledComponent<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, MentionPickerStyleProps, object>;
-export declare const MentionPickerInfoStyle: import("@emotion/styled-base").StyledComponent<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, Pick<import("react").ClassAttributes<HTMLDivElement> & import("react").HTMLAttributes<HTMLDivElement>, keyof import("react").HTMLAttributes<HTMLDivElement>>, object>;
+export declare const MentionPickerStyle: import("@emotion/styled").StyledComponent<{
+    theme?: import("@emotion/react").Theme | undefined;
+    as?: import("react").ElementType<any> | undefined;
+} & MentionPickerStyleProps, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
+export declare const MentionPickerInfoStyle: import("@emotion/styled").StyledComponent<{
+    theme?: import("@emotion/react").Theme | undefined;
+    as?: import("react").ElementType<any> | undefined;
+}, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;

package/dist/types/components/Scrollable/styles.d.ts

@@ -1,2 +1,5 @@
 /// <reference types="react" />
-export declare const ScrollableStyle: import("@emotion/styled-base").StyledComponent<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, Pick<import("react").ClassAttributes<HTMLDivElement> & import("react").HTMLAttributes<HTMLDivElement>, keyof import("react").HTMLAttributes<HTMLDivElement>>, object>;
+export declare const ScrollableStyle: import("@emotion/styled").StyledComponent<{
+    theme?: import("@emotion/react").Theme | undefined;
+    as?: import("react").ElementType<any> | undefined;
+}, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;

package/dist/types/components/TeamMentionHighlight/styles.d.ts

@@ -1,11 +1,33 @@
 /// <reference types="react" />
-export declare const Actions: import("@emotion/styled-base").StyledComponent<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, Pick<import("react").ClassAttributes<HTMLDivElement> & import("react").HTMLAttributes<HTMLDivElement>, keyof import("react").HTMLAttributes<HTMLDivElement>>, object>;
-export declare const Title: import("@emotion/styled-base").StyledComponent<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, Pick<import("@emotion/styled-base/types/helper").Overwrapped<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, import("@atlaskit/theme").ThemeProps | undefined>, never>, {
-    __ATLASKIT_THEME__: import("@atlaskit/theme").Theme;
-}>;
-export declare const Heading: import("@emotion/styled-base").StyledComponent<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, Pick<import("react").ClassAttributes<HTMLDivElement> & import("react").HTMLAttributes<HTMLDivElement>, keyof import("react").HTMLAttributes<HTMLDivElement>>, object>;
-export declare const Card: import("@emotion/styled-base").StyledComponent<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, Pick<import("react").ClassAttributes<HTMLDivElement> & import("react").HTMLAttributes<HTMLDivElement>, keyof import("react").HTMLAttributes<HTMLDivElement>>, object>;
-export declare const Content: import("@emotion/styled-base").StyledComponent<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, Pick<import("react").ClassAttributes<HTMLDivElement> & import("react").HTMLAttributes<HTMLDivElement>, keyof import("react").HTMLAttributes<HTMLDivElement>>, object>;
-export declare const Section: import("@emotion/styled-base").StyledComponent<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, Pick<import("react").ClassAttributes<HTMLDivElement> & import("react").HTMLAttributes<HTMLDivElement>, keyof import("react").HTMLAttributes<HTMLDivElement>>, object>;
-export declare const Aside: import("@emotion/styled-base").StyledComponent<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, Pick<import("react").ClassAttributes<HTMLDivElement> & import("react").HTMLAttributes<HTMLDivElement>, keyof import("react").HTMLAttributes<HTMLDivElement>>, object>;
-export declare const Body: import("@emotion/styled-base").StyledComponent<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, Pick<import("react").ClassAttributes<HTMLDivElement> & import("react").HTMLAttributes<HTMLDivElement>, keyof import("react").HTMLAttributes<HTMLDivElement>>, object>;
+export declare const Actions: import("@emotion/styled").StyledComponent<{
+    theme?: import("@emotion/react").Theme | undefined;
+    as?: import("react").ElementType<any> | undefined;
+}, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
+export declare const Title: import("@emotion/styled").StyledComponent<{
+    theme?: import("@emotion/react").Theme | undefined;
+    as?: import("react").ElementType<any> | undefined;
+}, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
+export declare const Heading: import("@emotion/styled").StyledComponent<{
+    theme?: import("@emotion/react").Theme | undefined;
+    as?: import("react").ElementType<any> | undefined;
+}, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
+export declare const Card: import("@emotion/styled").StyledComponent<{
+    theme?: import("@emotion/react").Theme | undefined;
+    as?: import("react").ElementType<any> | undefined;
+}, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
+export declare const Content: import("@emotion/styled").StyledComponent<{
+    theme?: import("@emotion/react").Theme | undefined;
+    as?: import("react").ElementType<any> | undefined;
+}, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
+export declare const Section: import("@emotion/styled").StyledComponent<{
+    theme?: import("@emotion/react").Theme | undefined;
+    as?: import("react").ElementType<any> | undefined;
+}, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
+export declare const Aside: import("@emotion/styled").StyledComponent<{
+    theme?: import("@emotion/react").Theme | undefined;
+    as?: import("react").ElementType<any> | undefined;
+}, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
+export declare const Body: import("@emotion/styled").StyledComponent<{
+    theme?: import("@emotion/react").Theme | undefined;
+    as?: import("react").ElementType<any> | undefined;
+}, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;

package/dist/types-ts4.0/_constants.d.ts

@@ -0,0 +1 @@
+export declare const ELEMENTS_CHANNEL = "fabric-elements";

package/dist/types-ts4.0/api/ContextMentionResource.d.ts

@@ -0,0 +1,23 @@
+import { MentionProvider, MentionContextIdentifier, ErrorCallback, InfoCallback, ResultCallback } from './MentionResource';
+import { MentionDescription, InviteFromMentionProvider } from '../types';
+export type { MentionDescription };
+export declare type MentionProviderFunctions = Omit<{
+    [Key in keyof MentionProvider]: MentionProvider[Key] extends Function ? MentionProvider[Key] : never;
+}, keyof InviteFromMentionProvider>;
+/**
+ * This component is stateful and should be instantianted per contextIdentifiers.
+ */
+export default class ContextMentionResource implements MentionProvider {
+    private mentionProvider;
+    private contextIdentifier;
+    constructor(mentionProvider: MentionProvider, contextIdentifier: MentionContextIdentifier);
+    getContextIdentifier(): MentionContextIdentifier | undefined;
+    callWithContextIds: <K extends "subscribe" | "unsubscribe" | "filter" | "recordMentionSelection" | "shouldHighlightMention" | "isFiltering">(f: K, declaredArgs: number) => MentionProvider[K];
+    callDefault: <K extends "subscribe" | "unsubscribe" | "filter" | "recordMentionSelection" | "shouldHighlightMention" | "isFiltering">(f: K) => MentionProvider[K];
+    subscribe: (key: string, callback?: ResultCallback<MentionDescription[]> | undefined, errCallback?: ErrorCallback | undefined, infoCallback?: InfoCallback | undefined, allResultsCallback?: ResultCallback<MentionDescription[]> | undefined, analyticsCallback?: import("../types").AnalyticsCallback | undefined) => void;
+    unsubscribe: (key: string) => void;
+    filter: (query?: string | undefined, contextIdentifier?: MentionContextIdentifier | undefined) => void;
+    recordMentionSelection: (mention: MentionDescription, contextIdentifier?: MentionContextIdentifier | undefined) => void;
+    shouldHighlightMention: (mention: MentionDescription) => boolean;
+    isFiltering: (query: string) => boolean;
+}

package/dist/types-ts4.0/api/MentionNameClient.d.ts

@@ -0,0 +1,11 @@
+import { MentionNameDetails } from '../types';
+export interface MentionNameClient {
+    getLookupLimit(): number;
+    lookupMentionNames(ids: string[]): Promise<MentionNameDetails[]>;
+}
+/**
+ * Supports the Atlassian Profile retrieval service.
+ *
+ * Uses:
+ *   https://statlas.prod.atl-paas.net/swagger-ui-2.2.6/index.html?url=https://profile-retrieval-service.prod.atl-paas.net:443/api/swagger.yaml#!/default/getUsersByIds
+ */

package/dist/types-ts4.0/api/MentionNameResolver.d.ts

@@ -0,0 +1,23 @@
+import { WithAnalyticsEventsProps } from '@atlaskit/analytics-next';
+import { MentionNameDetails, MentionNameResolver } from '../types';
+import { MentionNameClient } from './MentionNameClient';
+export type { MentionNameResolver } from '../types';
+export declare class DefaultMentionNameResolver implements MentionNameResolver {
+    static waitForBatch: number;
+    private client;
+    private nameCache;
+    private nameQueue;
+    private nameStartTime;
+    private processingQueue;
+    private debounce;
+    private fireHydrationEvent;
+    constructor(client: MentionNameClient, analyticsProps?: WithAnalyticsEventsProps);
+    lookupName(id: string): Promise<MentionNameDetails> | MentionNameDetails;
+    cacheName(id: string, name: string): void;
+    private scheduleProcessQueue;
+    private isQueueAtLimit;
+    private splitQueueAtLimit;
+    private resolveQueueItem;
+    private processQueue;
+    private fireAnalytics;
+}

package/dist/types-ts4.0/api/MentionResource.d.ts

@@ -0,0 +1,99 @@
+import { AnalyticsCallback, ErrorCallback, InfoCallback, InviteExperimentCohort, InviteFlow, MentionContextIdentifier, MentionDescription, MentionNameDetails, MentionProvider, MentionResourceConfig, MentionsResult, MentionStats, ResourceProvider, ResultCallback, UserRole } from '../types';
+export type { MentionStats, ResultCallback, ErrorCallback, InfoCallback, MentionResourceConfig, ResourceProvider, MentionContextIdentifier, MentionProvider, } from '../types';
+export interface TeamMentionResourceConfig extends MentionResourceConfig {
+    teamLinkResolver?: (teamId: string) => string;
+    teamHighlightEnabled?: boolean;
+    createTeamPath?: string;
+}
+export interface TeamMentionProvider extends MentionProvider {
+    mentionTypeaheadHighlightEnabled: () => boolean;
+    mentionTypeaheadCreateTeamPath: () => string | undefined;
+}
+/**
+ * Support
+ */
+export interface ResolvingMentionProvider extends MentionProvider {
+    resolveMentionName(id: string): Promise<MentionNameDetails> | MentionNameDetails;
+    cacheMentionName(id: string, mentionName: string): void;
+    supportsMentionNameResolving(): boolean;
+}
+declare class AbstractResource<Result> implements ResourceProvider<Result> {
+    protected changeListeners: Map<string, ResultCallback<Result>>;
+    protected errListeners: Map<string, ErrorCallback>;
+    protected infoListeners: Map<string, InfoCallback>;
+    protected allResultsListeners: Map<string, ResultCallback<Result>>;
+    protected analyticsListeners: Map<string, AnalyticsCallback>;
+    constructor();
+    subscribe(key: string, callback?: ResultCallback<Result>, errCallback?: ErrorCallback, infoCallback?: InfoCallback, allResultsCallback?: ResultCallback<Result>, analyticsListeners?: AnalyticsCallback): void;
+    unsubscribe(key: string): void;
+}
+declare class AbstractMentionResource extends AbstractResource<MentionDescription[]> implements MentionProvider {
+    shouldHighlightMention(_mention: MentionDescription): boolean;
+    filter(query?: string): void;
+    recordMentionSelection(_mention: MentionDescription): void;
+    isFiltering(_query: string): boolean;
+    protected _notifyListeners(mentionsResult: MentionsResult, stats?: MentionStats): void;
+    protected _notifyAllResultsListeners(mentionsResult: MentionsResult): void;
+    protected _notifyErrorListeners(error: Error, query?: string): void;
+    protected _notifyInfoListeners(info: string): void;
+    protected _notifyAnalyticsListeners(event: string, actionSubject: string, action: string, attributes?: {
+        [key: string]: any;
+    }): void;
+}
+/**
+ * Provides a Javascript API
+ */
+export declare class MentionResource extends AbstractMentionResource implements ResolvingMentionProvider {
+    private config;
+    private lastReturnedSearch;
+    private activeSearches;
+    productName?: string;
+    shouldEnableInvite: boolean;
+    inviteExperimentCohort?: InviteExperimentCohort;
+    userRole: UserRole;
+    onInviteItemClick?: (flow: InviteFlow) => void;
+    constructor(config: MentionResourceConfig);
+    shouldHighlightMention(mention: MentionDescription): boolean;
+    notify(searchTime: number, mentionResult: MentionsResult, query?: string): void;
+    notifyError(error: Error, query?: string): void;
+    filter(query?: string, contextIdentifier?: MentionContextIdentifier): Promise<void>;
+    recordMentionSelection(mention: MentionDescription, contextIdentifier?: MentionContextIdentifier): Promise<void>;
+    isFiltering(query: string): boolean;
+    resolveMentionName(id: string): Promise<MentionNameDetails> | MentionNameDetails;
+    cacheMentionName(id: string, mentionName: string): void;
+    supportsMentionNameResolving(): boolean;
+    protected updateActiveSearches(query: string): void;
+    protected verifyMentionConfig(config: MentionResourceConfig): void;
+    private initialState;
+    /**
+     * Clear a context object to generate query params by removing empty
+     * strings, `undefined` and empty values.
+     *
+     * @param contextIdentifier the current context identifier
+     * @returns a safe context for query encoding
+     */
+    private clearContext;
+    private getQueryParams;
+    /**
+     * Returns the initial mention display list before a search is performed for the specified
+     * container.
+     *
+     * @param contextIdentifier
+     * @returns Promise
+     */
+    protected remoteInitialState(contextIdentifier?: MentionContextIdentifier): Promise<MentionsResult>;
+    private search;
+    protected remoteSearch(query: string, contextIdentifier?: MentionContextIdentifier): Promise<MentionsResult>;
+    private transformServiceResponse;
+    recordSelection(mention: MentionDescription, contextIdentifier?: MentionContextIdentifier): Promise<void>;
+}
+export declare class HttpError implements Error {
+    name: string;
+    message: string;
+    statusCode: number;
+    stack?: string;
+    constructor(statusCode: number, statusMessage: string);
+}
+export declare const isResolvingMentionProvider: (p: any) => p is ResolvingMentionProvider;
+export { AbstractResource, AbstractMentionResource };
+export default MentionResource;

package/dist/types-ts4.0/api/PresenceResource.d.ts

@@ -0,0 +1,119 @@
+import { Presence } from '../types';
+import { AbstractResource, ResourceProvider } from './MentionResource';
+export interface PresenceMap {
+    [userId: string]: Presence;
+}
+export interface PresenceResourceConfig {
+    url: string;
+    cloudId: string;
+    productId?: string;
+    cache?: PresenceCache;
+    cacheExpiry?: number;
+    parser?: PresenceParser;
+}
+export interface PresenceCache {
+    contains(userId: string): boolean;
+    get(userId: string): Presence;
+    getBulk(userIds: string[]): PresenceMap;
+    getMissingUserIds(userIds: string[]): string[];
+    update(presUpdate: PresenceMap): void;
+}
+export interface PresenceResponse {
+    data: Data;
+}
+export interface Data {
+    PresenceBulk: PresenceBulk[];
+}
+export interface PresenceBulk {
+    userId: string;
+    state: null | string;
+    type: null | string;
+    date: null | string;
+    message: null | string;
+    stateMetadata?: string;
+}
+export interface PresenceParser {
+    mapState(state: string): string;
+    parse(response: PresenceResponse): PresenceMap;
+}
+export interface PresenceProvider extends ResourceProvider<PresenceMap> {
+    refreshPresence(userIds: string[]): void;
+}
+declare class AbstractPresenceResource extends AbstractResource<PresenceMap> implements PresenceProvider {
+    refreshPresence(userIds: string[]): void;
+    protected notifyListeners(presences: PresenceMap): void;
+}
+declare class PresenceResource extends AbstractPresenceResource {
+    private config;
+    private presenceCache;
+    private presenceParser;
+    constructor(config: PresenceResourceConfig);
+    refreshPresence(userIds: string[]): void;
+    private retrievePresence;
+    private queryDirectoryForPresences;
+    private static cleanUrl;
+}
+export declare class DefaultPresenceCache implements PresenceCache {
+    private static readonly defaultTimeout;
+    private static readonly defaultFlushTrigger;
+    private cache;
+    private size;
+    private expiryInMillis;
+    private flushTrigger;
+    constructor(cacheTimeout?: number, cacheTrigger?: number);
+    /**
+     * Precondition: _delete is only called internally if userId exists in cache
+     * Removes cache entry
+     * @param userId
+     */
+    private _delete;
+    /**
+     * Checks a cache entry and calls delete if the info has expired
+     * @param userId
+     */
+    private _deleteIfExpired;
+    /**
+     * Cleans expired entries from cache
+     */
+    private _removeExpired;
+    /**
+     * Checks if a user exists in the cache
+     * @param userId
+     */
+    contains(userId: string): boolean;
+    /**
+     * Retrieves a presence from the cache after checking for expired entries
+     * @param userId - to index the cache
+     * @returns Presence - the presence that matches the userId
+     */
+    get(userId: string): Presence;
+    /**
+     * Retrieve multiple presences at once from the cache
+     * @param userIds - to index the cache
+     * @returns PresenceMap - A map of userIds to cached Presences
+     */
+    getBulk(userIds: string[]): PresenceMap;
+    /**
+     * For a given list of ids, returns a subset
+     * of all the ids with missing cache entries.
+     * @param userIds - to index the cache
+     * @returns string[] - ids missing from the cache
+     */
+    getMissingUserIds(userIds: string[]): string[];
+    /**
+     * Precondition: presMap only contains ids of users not in cache
+     *               expired users must first be removed then reinserted with updated presence
+     * Updates the cache by adding the new Presence entries and setting the expiry time
+     * @param presMap
+     */
+    update(presMap: PresenceMap): void;
+}
+export declare class DefaultPresenceParser implements PresenceParser {
+    static FOCUS_STATE: string;
+    mapState(state: string): string;
+    parse(response: PresenceResponse): PresenceMap;
+    private static extractState;
+    private static isFocusState;
+}
+export { AbstractPresenceResource };
+export default PresenceResource;

package/dist/types-ts4.0/api/TeamMentionResource.d.ts

@@ -0,0 +1,35 @@
+import { MentionsResult } from '../types';
+import MentionResource, { MentionContextIdentifier, MentionResourceConfig, TeamMentionResourceConfig, TeamMentionProvider } from './MentionResource';
+/**
+ * Provides a Javascript API to fetch users and teams
+ * In future we will have a new endpoint to return both users and teams, we can
+ * remove this class at this point
+ */
+export default class TeamMentionResource extends MentionResource implements TeamMentionProvider {
+    private readonly teamMentionConfig;
+    private lastSearchQuery?;
+    private lastReturnedSearchTeam;
+    constructor(userMentionConfig: MentionResourceConfig, teamMentionConfig: TeamMentionResourceConfig);
+    filter(query?: string, contextIdentifier?: MentionContextIdentifier): Promise<void>;
+    mentionTypeaheadHighlightEnabled: () => boolean;
+    mentionTypeaheadCreateTeamPath: () => string | undefined;
+    /**
+     * Returns the initial mention display list before a search is performed for the specified
+     * container.
+     */
+    private remoteInitialStateTeamAndUsers;
+    /**
+     * Both user and team requests are not blocked together
+     * If users request arrives first, show users. Show teams when team request arrives.
+     * If team request arrives first, block waiting for user request, then show both
+     * If one errors, show the non-erroring one
+     * If both error, show error
+     */
+    private handleBothRequests;
+    notify(searchTime: number, mentionResult: MentionsResult, query?: string): void;
+    private getQueryParamsOfTeamMentionConfig;
+    private remoteUserSearch;
+    private remoteTeamSearch;
+    private convertTeamResultToMentionResult;
+    private trimTeamARI;
+}