@atlaskit/editor-common 76.9.1 → 76.9.2

package/dist/types-ts4.5/collab/index.d.ts

@@ -0,0 +1,379 @@
+import type { ReactElement } from 'react';
+import type { JSONDocNode } from '@atlaskit/editor-json-transformer';
+import type { EditorState, Transaction } from '@atlaskit/editor-prosemirror/state';
+import type { Step } from '@atlaskit/editor-prosemirror/transform';
+import type { Providers } from '../provider-factory';
+export type NewCollabSyncUpErrorAttributes = {
+    lengthOfUnconfirmedSteps?: number;
+    tries: number;
+    maxRetries: number;
+    clientId?: number | string;
+    version: number;
+};
+export type ResolvedEditorState<T = any> = {
+    content: JSONDocNode | T;
+    title: string | null;
+    stepVersion: number;
+};
+export declare enum PROVIDER_ERROR_CODE {
+    NO_PERMISSION_ERROR = "NO_PERMISSION_ERROR",
+    INVALID_USER_TOKEN = "INVALID_USER_TOKEN",
+    DOCUMENT_NOT_FOUND = "DOCUMENT_NOT_FOUND",
+    LOCKED = "LOCKED",
+    FAIL_TO_SAVE = "FAIL_TO_SAVE",
+    DOCUMENT_RESTORE_ERROR = "DOCUMENT_RESTORE_ERROR",
+    INITIALISATION_ERROR = "INITIALISATION_ERROR",
+    NETWORK_ISSUE = "NETWORK_ISSUE",
+    INVALID_PROVIDER_CONFIGURATION = "INVALID_PROVIDER_CONFIGURATION",
+    INTERNAL_SERVICE_ERROR = "INTERNAL_SERVICE_ERROR",
+    DOCUMENT_UPDATE_ERROR = "DOCUMENT_UPDATE_ERROR"
+}
+/**
+ * This occurs when the provided user token is considered invalid for the given document ARI.
+ * It happens during initialisation of the provider.
+ * It could mean the document has been deleted (hence not found).
+ * @message Message returned to editor, i.e User does not have permissions to access this document or document is not found
+ * @recoverable It is recoverable, as we will try to refresh the token.
+ */
+type InsufficientEditingPermission = {
+    code: PROVIDER_ERROR_CODE.NO_PERMISSION_ERROR;
+    message: string;
+    recoverable: boolean;
+    reason?: string;
+    /**
+     * @deprecated switch to using either the error code or the recoverable flag
+     */
+    status?: number;
+};
+/**
+ * Similar to InsufficientEditingPermission, but the user token is invalid because it has expired or been revoked.
+ * It may also be an invalid token format.
+ * This error is given to the provider by NCS.
+ * @message Message returned to editor, i.e. The user token was invalid
+ * @recoverable It is recoverable, as we will try to refresh the token.
+ */
+type InvalidUserToken = {
+    code: PROVIDER_ERROR_CODE.INVALID_USER_TOKEN;
+    message: string;
+    recoverable: boolean;
+    /**
+     * @deprecated switch to using either the error code or the recoverable flag
+     */
+    status?: number;
+};
+/**
+ * Document not found error, thrown when the provider is unable to find a document with the given ARI and user token.
+ * It occurs during fetchCatchup, a function that fetches the latest document state during catchup.
+ * We need to recieve a 404 from the document service to throw this error.
+ * @message Message returned to editor, i.e. The requested document is not found
+ * @recoverable It is recoverable, as the provider can try again later.
+ */
+type DocumentNotFound = {
+    code: PROVIDER_ERROR_CODE.DOCUMENT_NOT_FOUND;
+    message: string;
+    recoverable: boolean;
+    /**
+     * @deprecated switch to using either the error code or the recoverable flag
+     */
+    status?: number;
+};
+/**
+ * This error is thrown when the document is locked by another user.
+ * The error is passed to us by NCS.
+ * @message Message returned to editor, i.e. The document is currently not available, please try again later
+ * @recoverable It is recoverable, as the provider can try again later.
+ */
+type Locked = {
+    code: PROVIDER_ERROR_CODE.LOCKED;
+    message: string;
+    recoverable: boolean;
+    status?: number;
+};
+/**
+ * This error is thrown when the provider is unable to save the document.
+ * This can happen when the connection to dynamoDB is lost, or when we do not have sufficient permissions (DYNAMO ERROR).
+ * This error is given to us by NCS.
+ * @message Message returned to editor, i.e. Collab service is not able to save changes
+ * @recoverable It is not recoverable, as we don't want the user to continue editing a document that is not being saved.
+ */
+type FailToSave = {
+    code: PROVIDER_ERROR_CODE.FAIL_TO_SAVE;
+    message: string;
+    recoverable: boolean;
+    /**
+     * @deprecated switch to using either the error code or the recoverable flag
+     */
+    status?: number;
+};
+/**
+ * This error is thrown when the provider is unable to restore the document.
+ * It occurs during onRestore, a function that restores the document to a previous version and reapplies unconfirmed steps.
+ * onRestore is called when page recovery has emitted an 'init' event on a page client is currently connected to.
+ * It could mean we failed to update the page metadata, or we failed to reapply unconfirmed steps.
+ * @message Message returned to editor, i.e. Collab service unable to restore document
+ * @recoverable It is not recoverable, as the provider has no further options after this.
+ * The user will need to refresh the page to try again.
+ */
+type DocumentNotRestore = {
+    code: PROVIDER_ERROR_CODE.DOCUMENT_RESTORE_ERROR;
+    message: string;
+    recoverable: boolean;
+    /**
+     * @deprecated switch to using either the error code or the recoverable flag
+     */
+    status?: number;
+};
+/**
+ * The initial document couldn't be loaded from the collab service.
+ * This error is given to us by NCS.
+ * It could indicate either a network issue, or an internal service error in NCS.
+ * @message Message returned to editor, i.e. The initial document couldn't be loaded from the collab service
+ * @recoverable It is not recoverable, as the provider cannot do anything to fix it.
+ * The user will need to refresh the page to try again.
+ */
+type InitialisationError = {
+    code: PROVIDER_ERROR_CODE.INITIALISATION_ERROR;
+    message: string;
+    recoverable: boolean;
+    /**
+     * @deprecated switch to using either the error code or the recoverable flag
+     */
+    status?: number;
+};
+/**
+ * Couldn't reconnect to the collab service (NCS) due to network issues.
+ * NCS could be down, or the user could be offline. It's also possible the url is incorrect, or the user is behind a proxy blocking the connection.
+ * Fired upon a reconnection attempt error (from Socket.IO Manager)
+ * @message Message returned to editor, i.e. Couldn't reconnect to the collab service due to network issues
+ * @recoverable It is recoverable, as the provider will try to reconnect.
+ */
+type NetworkIssue = {
+    code: PROVIDER_ERROR_CODE.NETWORK_ISSUE;
+    message: string;
+    recoverable: boolean;
+    /**
+     * @deprecated switch to using either the error code or the recoverable flag
+     */
+    status?: number;
+};
+/**
+ * This error is thrown when the provider has an invalid configuration.
+ * It could happen due to these errors from NCS:
+ *  NAMESPACE_INVALID
+    INVALID_ACTIVATION_ID
+    INVALID_DOCUMENT_ARI
+    INVALID_CLOUD_ID
+ * @message Message returned to editor, i.e. Invalid provider configuration
+ * @recoverable It is not recoverable, as the provider cannot do anything to fix it.
+ * The service using the provider will need to fix the configuration.
+ */
+type InvalidProviderConfiguration = {
+    code: PROVIDER_ERROR_CODE.INVALID_PROVIDER_CONFIGURATION;
+    message: string;
+    recoverable: boolean;
+    reason: string;
+    /**
+     * @deprecated switch to using either the error code or the recoverable flag
+     */
+    status?: number;
+};
+/**
+ * This error is thrown when the provider encounters an internal service error, not otherwise accounted for.
+ * @message Message returned to editor, i.e. Collab Provider experienced an unrecoverable error
+ * @recoverable It is not recoverable, as the provider cannot do anything to fix it.
+ */
+type InternalServiceError = {
+    code: PROVIDER_ERROR_CODE.INTERNAL_SERVICE_ERROR;
+    message: string;
+    recoverable: boolean;
+    reason: string;
+    /**
+     * @deprecated switch to using either the error code or the recoverable flag
+     */
+    status?: number;
+};
+type ProviderDocumentUpdateError = {
+    code: PROVIDER_ERROR_CODE.DOCUMENT_UPDATE_ERROR;
+    message: 'The provider failed to apply changes to the editor';
+    recoverable: boolean;
+    /**
+     * @deprecated switch to using either the error code or the recoverable flag
+     */
+    status?: number;
+};
+/**
+ * A union of all possible provider errors that can be emitted back to the editor.
+ */
+export type ProviderError = InsufficientEditingPermission | InvalidUserToken | DocumentNotFound | Locked | FailToSave | DocumentNotRestore | InitialisationError | NetworkIssue | InvalidProviderConfiguration | InternalServiceError | ProviderDocumentUpdateError;
+export interface Metadata {
+    [key: string]: string | number | boolean;
+}
+export type CollabMetadataPayload = Metadata;
+export interface CollabEventInitData {
+    doc?: any;
+    json?: any;
+    version?: number;
+    sid?: string;
+    reserveCursor?: boolean;
+}
+export interface CollabInitPayload extends CollabEventInitData {
+    doc: any;
+    version: number;
+    metadata?: Metadata;
+    reserveCursor?: boolean;
+}
+export interface CollabEventConnectionData {
+    sid: string;
+    initial: boolean;
+}
+export type CollabConnectedPayload = CollabEventConnectionData;
+export declare enum DisconnectReason {
+    CLIENT_DISCONNECT = "CLIENT_DISCONNECT",
+    SERVER_DISCONNECT = "SERVER_DISCONNECT",
+    SOCKET_CLOSED = "SOCKET_CLOSED",
+    SOCKET_ERROR = "SOCKET_ERROR",
+    SOCKET_TIMEOUT = "SOCKET_TIMEOUT",
+    UNKNOWN_DISCONNECT = "UNKNOWN_DISCONNECT"
+}
+export interface CollabDisconnectedPayload {
+    reason: DisconnectReason;
+    sid: string;
+}
+export interface CollabEventRemoteData {
+    json?: any;
+    newState?: EditorState;
+    userIds?: (number | string)[];
+}
+type MarkJson = {
+    type: string;
+    attrs: {
+        [key: string]: any;
+    };
+};
+type NodeJson = {
+    type: string;
+    attrs: {
+        [key: string]: any;
+    };
+    content: NodeJson[];
+    marks: MarkJson[];
+    text?: string;
+};
+type SliceJson = {
+    content: NodeJson[];
+    openStart: number;
+    openEnd: number;
+};
+export type StepJson = {
+    stepType?: string;
+    from?: number;
+    to?: number;
+    slice?: SliceJson;
+    clientId: number | string;
+    userId: string;
+    createdAt?: number;
+    structure?: boolean;
+};
+export interface CollabDataPayload extends CollabEventRemoteData {
+    version: number;
+    json: StepJson[];
+    userIds: (number | string)[];
+}
+export interface CollabSendableSelection {
+    type: 'textSelection' | 'nodeSelection';
+    anchor?: number | string;
+    head?: number | string;
+}
+export interface CollabEventTelepointerData {
+    type: 'telepointer';
+    selection: CollabSendableSelection;
+    sessionId: string;
+}
+export type CollabTelepointerPayload = CollabEventTelepointerData;
+export interface CollabParticipant {
+    lastActive: number;
+    sessionId: string;
+    avatar: string;
+    name: string;
+    cursorPos?: number;
+}
+export type ProviderParticipant = CollabParticipant & {
+    userId: string;
+    clientId: number | string;
+    email: string;
+};
+export interface CollabEventPresenceData {
+    joined?: ProviderParticipant[];
+    left?: {
+        sessionId: string;
+    }[];
+}
+export type CollabPresencePayload = CollabEventPresenceData;
+export type CollabLocalStepsPayload = {
+    steps: readonly Step[];
+};
+export interface CollabEventConnectingData {
+    initial: boolean;
+}
+export type CollabConnectingPayload = CollabEventConnectingData;
+export type CollabCommitStatusEventPayload = {
+    status: 'attempt' | 'success' | 'failure';
+    version: number;
+};
+export interface CollabEvents {
+    'metadata:changed': Metadata;
+    init: CollabInitPayload;
+    connected: CollabConnectedPayload;
+    disconnected: CollabDisconnectedPayload;
+    data: CollabDataPayload;
+    telepointer: CollabTelepointerPayload;
+    presence: CollabPresencePayload;
+    'local-steps': CollabLocalStepsPayload;
+    error: ProviderError;
+    entity: any;
+    connecting: CollabConnectingPayload;
+    'commit-status': CollabCommitStatusEventPayload;
+}
+export type SyncUpErrorFunction = (attributes: NewCollabSyncUpErrorAttributes) => void;
+export interface CollabEditProvider<Events extends CollabEvents = CollabEvents> {
+    initialize(getState: () => any, createStep: (json: object) => Step): this;
+    setup(props: {
+        getState?: () => EditorState;
+        onSyncUpError?: SyncUpErrorFunction;
+    }): this;
+    send(tr: Transaction, oldState: EditorState, newState: EditorState): void;
+    on(evt: keyof Events, handler: (...args: any) => void): this;
+    off(evt: keyof Events, handler: (...args: any) => void): this;
+    unsubscribeAll(evt: keyof Events): this;
+    sendMessage<K extends keyof Events>(data: {
+        type: K;
+    } & Events[K]): void;
+    getFinalAcknowledgedState(): Promise<ResolvedEditorState>;
+}
+export type CollabEditOptions = {
+    provider?: Providers['collabEditProvider'];
+    userId?: string;
+    useNativePlugin?: boolean;
+} & CollabInviteToEditProps & CollabAnalyticsProps;
+export type InviteToEditButtonProps = {
+    onClick: (event: React.MouseEvent<HTMLElement>) => void;
+    selected: boolean;
+};
+export type InviteToEditComponentProps = {
+    children: ReactElement<InviteToEditButtonProps>;
+};
+export interface CollabInviteToEditProps {
+    inviteToEditHandler?: (event: React.MouseEvent<HTMLElement>) => void;
+    isInviteToEditButtonSelected?: boolean;
+    inviteToEditComponent?: React.ComponentType<InviteToEditComponentProps>;
+}
+export interface CollabAnalyticsProps {
+    /**
+     * @description Control whether Synchrony entity error events are tracked
+     */
+    EXPERIMENTAL_allowInternalErrorAnalytics?: boolean;
+}
+export interface CollabEventLocalStepData {
+    steps: Array<Step>;
+}
+export {};

package/dist/types-ts4.5/commands/index.d.ts

@@ -0,0 +1,21 @@
+import type { MarkType, NodeType, Node as PMNode, ResolvedPos, Schema } from '@atlaskit/editor-prosemirror/model';
+import type { EditorState, Transaction } from '@atlaskit/editor-prosemirror/state';
+import type { HeadingLevelsAndNormalText } from '../types/block-type';
+import type { Command } from '../types/command';
+type AlignmentState = 'start' | 'end' | 'center';
+export declare function addParagraphAtEnd(tr: Transaction): void;
+export declare function createParagraphAtEnd(): Command;
+export declare const changeImageAlignment: (align?: AlignmentState) => Command;
+export declare const createToggleBlockMarkOnRange: <T extends {} = object>(markType: MarkType, getAttrs: (prevAttrs?: T | undefined, node?: PMNode) => false | T | undefined, allowedBlocks?: NodeType[] | ((schema: Schema, node: PMNode, parent: PMNode | null) => boolean) | undefined) => (from: number, to: number, tr: Transaction, state: EditorState) => boolean;
+/**
+ * Toggles block mark based on the return type of `getAttrs`.
+ * This is similar to ProseMirror's `getAttrs` from `AttributeSpec`
+ * return `false` to remove the mark.
+ * return `undefined for no-op.
+ * return an `object` to update the mark.
+ */
+export declare const toggleBlockMark: <T extends {} = object>(markType: MarkType, getAttrs: (prevAttrs?: T | undefined, node?: PMNode) => false | T | undefined, allowedBlocks?: NodeType[] | ((schema: Schema, node: PMNode, parent: PMNode | null) => boolean) | undefined) => Command;
+export declare const clearEditorContent: Command;
+export declare function findCutBefore($pos: ResolvedPos): ResolvedPos | null;
+export declare function setHeading(level: HeadingLevelsAndNormalText): Command;
+export { insertBlock } from './insert-block';

package/dist/types-ts4.5/commands/insert-block.d.ts

@@ -0,0 +1,5 @@
+import type { NodeType } from '@atlaskit/editor-prosemirror/model';
+import type { EditorState, Transaction } from '@atlaskit/editor-prosemirror/state';
+export declare const insertBlock: (state: EditorState, nodeType: NodeType, start: number, end: number, attrs?: {
+    [key: string]: any;
+} | undefined) => Transaction | null;

package/dist/types-ts4.5/copy-button/index.d.ts

@@ -0,0 +1,7 @@
+import type { NodeType, Node as PMNode, Schema } from '@atlaskit/editor-prosemirror/model';
+import type { Transaction } from '@atlaskit/editor-prosemirror/state';
+export declare function getSelectedNodeOrNodeParentByNodeType({ nodeType, selection, }: {
+    nodeType: NodeType | Array<NodeType>;
+    selection: Transaction['selection'];
+}): import("prosemirror-utils/dist/types").FindResult;
+export declare const toDOM: (node: PMNode, schema: Schema) => Node;

package/dist/types-ts4.5/core-utils/index.d.ts

@@ -0,0 +1 @@
+export { insideTable } from './inside';

package/dist/types-ts4.5/core-utils/inside.d.ts

@@ -0,0 +1,2 @@
+import type { EditorState } from '@atlaskit/editor-prosemirror/state';
+export declare const insideTable: (state: EditorState) => Boolean;

package/dist/types-ts4.5/editor-analytics/index.d.ts

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

package/dist/types-ts4.5/editor-analytics/withAnalytics.d.ts

@@ -0,0 +1,34 @@
+import type { EditorState } from '@atlaskit/editor-prosemirror/state';
+import type { AnalyticsEventPayload, EditorAnalyticsAPI } from '../analytics';
+import type { HigherOrderCommand } from '../types';
+/**
+ * Callback accepts EditorState
+ *
+ * @remarks
+ * The plugin using the Analytics may using an Optional<Analytics> dependency
+ * It can be undefined during testing, we may not have included analytics
+ * Also in cases where Analytics fails to load, the editor doesn't crash.
+ *
+ * @param state - EditorState, passed to the callback
+ */
+type AnalyticsEventPayloadCallback = (state: EditorState) => AnalyticsEventPayload | undefined;
+/**
+ * Analytics API
+ * @example
+ * ```
+ * withAnalytics({
+ * eventType: EVENT_TYPE.TRACK,
+ * action: ACTION.REPLACED_ONE,
+ *  actionSubject: ACTION_SUBJECT.TEXT,
+ *   attributes: {
+ *    triggerMethod,
+ *  },
+ * })(replace(replaceText))
+ * ```
+ *
+ * @param analyticsApi - EditorAnalyticsAPI, undefined in tests or if analytics fails to load
+ * @param payload - AnalyticsEventPayload | AnalyticsEventPayloadCallback - payload to be attached to the transaction
+ * @param channel - string - channel to be used for analytics
+ */
+export declare function withAnalytics(analyticsApi: EditorAnalyticsAPI | undefined, payload: AnalyticsEventPayload | AnalyticsEventPayloadCallback, channel?: string): HigherOrderCommand;
+export {};

package/dist/types-ts4.5/element-browser/ElementBrowser.d.ts

@@ -0,0 +1,37 @@
+import { PureComponent } from 'react';
+import type { QuickInsertItem } from '../provider-factory';
+import type { EmptyStateHandler } from '../types';
+import type { Category, Modes } from './types';
+export interface Props {
+    categories?: Category[];
+    mode: keyof typeof Modes;
+    getItems: (query?: string, category?: string) => QuickInsertItem[];
+    onSelectItem?: (item: QuickInsertItem) => void;
+    onInsertItem: (item: QuickInsertItem) => void;
+    showSearch: boolean;
+    showCategories: boolean;
+    defaultCategory?: string;
+    emptyStateHandler?: EmptyStateHandler;
+    viewMoreItem?: QuickInsertItem;
+}
+export interface State {
+    items: QuickInsertItem[];
+    categories: Category[];
+    selectedCategory?: string;
+    searchTerm?: string;
+}
+export default class ElementBrowser extends PureComponent<Props, State> {
+    static defaultProps: {
+        defaultCategory: string;
+        onInsertItem: () => void;
+    };
+    state: State;
+    componentDidMount(): void;
+    getCategories: (items?: QuickInsertItem[]) => Category[];
+    filterCategories: (items: QuickInsertItem[], categories?: Category[]) => Category[];
+    fetchItems: (query?: string, category?: string) => QuickInsertItem[];
+    componentDidUpdate(prevProps: Props, prevState: State): void;
+    handleSearch: (searchTerm: string) => void;
+    handleCategorySelection: (clickedCategory: Category) => void;
+    render(): JSX.Element;
+}

package/dist/types-ts4.5/element-browser/ViewMore.d.ts

@@ -0,0 +1,6 @@
+import { jsx } from '@emotion/react';
+import type { QuickInsertItem } from '../provider-factory';
+export declare const ViewMore: ({ item, focus, }: {
+    item: QuickInsertItem;
+    focus: boolean;
+}) => jsx.JSX.Element;

package/dist/types-ts4.5/element-browser/components/CategoryList.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import type { WithAnalyticsEventsProps } from '@atlaskit/analytics-next';
+import type { Category } from '../types';
+interface Props {
+    categories?: Category[];
+    onSelectCategory: (category: Category) => void;
+    selectedCategory?: string;
+}
+declare const MemoizedCategoryListWithAnalytics: React.MemoExoticComponent<React.ForwardRefExoticComponent<Pick<Props & WithAnalyticsEventsProps & import("@atlaskit/analytics-next").WithContextProps, "createAnalyticsEvent" | "analyticsContext" | keyof Props> & React.RefAttributes<any>>>;
+export default MemoizedCategoryListWithAnalytics;

package/dist/types-ts4.5/element-browser/components/ElementBrowserLoader.d.ts

@@ -0,0 +1,6 @@
+/** @jsx jsx */
+import React from 'react';
+import Loadable from 'react-loadable';
+import type { Props as ElementBrowserProps } from '../ElementBrowser';
+declare const ElementBrowserLoader: React.ComponentType<ElementBrowserProps> & Loadable.LoadableComponent;
+export default ElementBrowserLoader;

package/dist/types-ts4.5/element-browser/components/ElementList/ElementList.d.ts

@@ -0,0 +1,33 @@
+/** @jsx jsx */
+import React from 'react';
+import { jsx } from '@emotion/react';
+import type { WithAnalyticsEventsProps } from '@atlaskit/analytics-next';
+import type { QuickInsertItem } from '../../../provider-factory';
+import type { EmptyStateHandler } from '../../../types';
+import type { SelectedItemProps } from '../../types';
+import { Modes } from '../../types';
+export declare const ICON_HEIGHT = 40;
+export declare const ICON_WIDTH = 40;
+export declare const itemIcon: import("@emotion/react").SerializedStyles;
+export interface Props {
+    items: QuickInsertItem[];
+    mode: keyof typeof Modes;
+    onInsertItem: (item: QuickInsertItem) => void;
+    setColumnCount: (columnCount: number) => void;
+    setFocusedItemIndex: (index: number) => void;
+    emptyStateHandler?: EmptyStateHandler;
+    selectedCategory?: string;
+    searchTerm?: string;
+}
+type ElementItemType = {
+    inlineMode: boolean;
+    item: QuickInsertItem;
+    onInsertItem: (item: QuickInsertItem) => void;
+    selected: boolean;
+    focus: boolean;
+    setFocusedItemIndex: (index: number) => void;
+    index: number;
+};
+export declare function ElementItem({ inlineMode, selected, item, index, onInsertItem, focus, setFocusedItemIndex, }: ElementItemType): jsx.JSX.Element;
+declare const MemoizedElementListWithAnalytics: React.MemoExoticComponent<React.ForwardRefExoticComponent<Pick<Props & SelectedItemProps & WithAnalyticsEventsProps & import("@atlaskit/analytics-next").WithContextProps, "createAnalyticsEvent" | "analyticsContext" | keyof Props | keyof SelectedItemProps> & React.RefAttributes<any>>>;
+export default MemoizedElementListWithAnalytics;

package/dist/types-ts4.5/element-browser/components/ElementList/EmptyState.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+type Props = {
+    onExternalLinkClick: () => void;
+};
+export default function EmptyState({ onExternalLinkClick, }: Props): JSX.Element;
+export {};

package/dist/types-ts4.5/element-browser/components/ElementList/NotFoundIllustration.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="react" />
+export default function NotFoundIllustration(): JSX.Element;

package/dist/types-ts4.5/element-browser/components/ElementList/cellSizeAndPositionGetter.d.ts

@@ -0,0 +1,7 @@
+import type { CollectionCellSizeAndPositionGetter } from 'react-virtualized/dist/commonjs/Collection';
+/**
+ * Callback responsible for returning size and offset/position information
+ * for a given cell.
+ * https://github.com/bvaughn/react-virtualized/blob/master/docs/Collection.md
+ **/
+export default function cellSizeAndPositionGetter(containerWidth: number, scrollbarWidth: number): CollectionCellSizeAndPositionGetter;

package/dist/types-ts4.5/element-browser/components/ElementList/utils.d.ts

@@ -0,0 +1,12 @@
+export declare function getColumnCount(clientWidth: number): number;
+type DatumReturnType = {
+    availableWidth: number;
+    columnCount: number;
+};
+type Options = {
+    gutterSize: number;
+    scrollbarWidth: number;
+};
+export declare function generateVirtualizedContainerDatum(containerWidth: number, options: Options): DatumReturnType;
+export declare function getScrollbarWidth(): number;
+export {};

package/dist/types-ts4.5/element-browser/components/ElementSearch.d.ts

@@ -0,0 +1,18 @@
+/** @jsx jsx */
+import React from 'react';
+import type { WrappedComponentProps } from 'react-intl-next';
+import { Modes } from '../types';
+interface Props {
+    onSearch: (value: string) => void;
+    mode: keyof typeof Modes;
+    focus: boolean;
+    onClick: (e: React.MouseEvent) => void;
+    onKeyDown: (e: React.KeyboardEvent) => void;
+    searchTerm?: string;
+}
+declare const MemoizedElementSearchWithAnalytics: React.MemoExoticComponent<React.ForwardRefExoticComponent<Omit<Props & WrappedComponentProps<"intl">, "intl"> & {
+    forwardedRef?: React.Ref<any> | undefined;
+} & {
+    children?: React.ReactNode;
+} & import("@atlaskit/analytics-next").WithContextProps & React.RefAttributes<any>>>;
+export default MemoizedElementSearchWithAnalytics;

package/dist/types-ts4.5/element-browser/components/StatelessElementBrowser.d.ts

@@ -0,0 +1,23 @@
+/** @jsx jsx */
+import React from 'react';
+import type { WithAnalyticsEventsProps } from '@atlaskit/analytics-next';
+import type { QuickInsertItem } from '../../provider-factory';
+import type { EmptyStateHandler } from '../../types';
+import type { Category, Modes } from '../types';
+export type StatelessElementBrowserProps = {
+    categories?: Category[];
+    items: QuickInsertItem[];
+    onSearch: (searchTerm: string) => void;
+    onSelectCategory: (category: Category) => void;
+    onSelectItem?: (item: QuickInsertItem) => void;
+    onInsertItem: (item: QuickInsertItem) => void;
+    selectedCategory?: string;
+    showSearch: boolean;
+    showCategories: boolean;
+    mode: keyof typeof Modes;
+    searchTerm?: string;
+    emptyStateHandler?: EmptyStateHandler;
+    viewMoreItem?: QuickInsertItem;
+} & WithAnalyticsEventsProps;
+declare const MemoizedElementBrowser: React.MemoExoticComponent<React.ForwardRefExoticComponent<Pick<Omit<StatelessElementBrowserProps, keyof WithAnalyticsEventsProps> & React.RefAttributes<any> & import("@atlaskit/analytics-next").WithContextProps, "key" | "mode" | "analyticsContext" | "categories" | "onSelectCategory" | "selectedCategory" | "items" | "emptyStateHandler" | "searchTerm" | "onInsertItem" | "onSearch" | "onSelectItem" | "viewMoreItem" | "showCategories" | "showSearch"> & React.RefAttributes<any>>>;
+export default MemoizedElementBrowser;

package/dist/types-ts4.5/element-browser/constants.d.ts

@@ -0,0 +1,19 @@
+export declare const GRID_SIZE: number;
+export declare const DEVICE_BREAKPOINT_NUMBERS: {
+    small: number;
+    medium: number;
+    large: number;
+};
+export declare const FLEX_ITEMS_CONTAINER_BREAKPOINT_NUMBERS: {
+    small: number;
+    medium: number;
+    large: number;
+};
+export declare const SIDEBAR_WIDTH: string;
+export declare const SIDEBAR_HEADING_WRAPPER_HEIGHT: string;
+export declare const SIDEBAR_HEADING_PADDING_LEFT = "12px";
+export declare const INLINE_SIDEBAR_HEIGHT = "54px";
+export declare const SEARCH_ITEM_HEIGHT_WIDTH = "20px";
+export declare const SCROLLBAR_WIDTH = 15;
+export declare const ELEMENT_LIST_PADDING = 2;
+export declare const ELEMENT_ITEM_HEIGHT = 75;