@atlaskit/renderer 108.15.10 → 108.15.12

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

@@ -0,0 +1,8 @@
+import { Fragment, Schema } from '@atlaskit/editor-prosemirror/model';
+import { Serializer } from '../serializer';
+export default class TextSerializer implements Serializer<string> {
+    private schema;
+    constructor(schema: Schema);
+    serializeFragment(fragment: Fragment): string;
+    static fromSchema(schema?: Schema): TextSerializer;
+}

package/dist/types-ts4.5/text/nodes/blockquote.d.ts

@@ -0,0 +1,3 @@
+import { NodeReducer } from './';
+declare const blockquote: NodeReducer;
+export default blockquote;

package/dist/types-ts4.5/text/nodes/bulletList.d.ts

@@ -0,0 +1,3 @@
+import { NodeReducer } from './';
+declare const bulletList: NodeReducer;
+export default bulletList;

package/dist/types-ts4.5/text/nodes/date.d.ts

@@ -0,0 +1,3 @@
+import { NodeReducer } from './';
+declare const date: NodeReducer;
+export default date;

package/dist/types-ts4.5/text/nodes/decisionItem.d.ts

@@ -0,0 +1,3 @@
+import { NodeReducer } from './';
+declare const decisionItem: NodeReducer;
+export default decisionItem;

package/dist/types-ts4.5/text/nodes/hardBreak.d.ts

@@ -0,0 +1,3 @@
+import { NodeReducer } from './';
+declare const hardBreak: NodeReducer;
+export default hardBreak;

package/dist/types-ts4.5/text/nodes/heading.d.ts

@@ -0,0 +1,3 @@
+import { NodeReducer } from './';
+declare const heading: NodeReducer;
+export default heading;

package/dist/types-ts4.5/text/nodes/index.d.ts

@@ -0,0 +1,6 @@
+import { Node as PMNode, Schema } from '@atlaskit/editor-prosemirror/model';
+export type NodeReducer = (node: PMNode, schema: Schema) => string;
+export declare const reduce: NodeReducer;
+export declare const nodeToReducerMapping: {
+    [key: string]: NodeReducer;
+};

package/dist/types-ts4.5/text/nodes/inlineCard.d.ts

@@ -0,0 +1,3 @@
+import { NodeReducer } from './';
+declare const inlineCard: NodeReducer;
+export default inlineCard;

package/dist/types-ts4.5/text/nodes/listItem.d.ts

@@ -0,0 +1,3 @@
+import { NodeReducer } from './';
+declare const listItem: NodeReducer;
+export default listItem;

package/dist/types-ts4.5/text/nodes/mediaGroup.d.ts

@@ -0,0 +1,3 @@
+import { NodeReducer } from './';
+declare const mediaGroup: NodeReducer;
+export default mediaGroup;

package/dist/types-ts4.5/text/nodes/mention.d.ts

@@ -0,0 +1,3 @@
+import { NodeReducer } from './';
+declare const mention: NodeReducer;
+export default mention;

package/dist/types-ts4.5/text/nodes/orderedList.d.ts

@@ -0,0 +1,3 @@
+import { NodeReducer } from './';
+declare const orderedList: NodeReducer;
+export default orderedList;

package/dist/types-ts4.5/text/nodes/panel.d.ts

@@ -0,0 +1,3 @@
+import { NodeReducer } from './';
+declare const panel: NodeReducer;
+export default panel;

package/dist/types-ts4.5/text/nodes/paragraph.d.ts

@@ -0,0 +1,3 @@
+import { NodeReducer } from './';
+declare const paragraph: NodeReducer;
+export default paragraph;

package/dist/types-ts4.5/text/nodes/rule.d.ts

@@ -0,0 +1,3 @@
+import { NodeReducer } from './';
+declare const rule: NodeReducer;
+export default rule;

package/dist/types-ts4.5/text/nodes/status.d.ts

@@ -0,0 +1,3 @@
+import { NodeReducer } from './';
+declare const status: NodeReducer;
+export default status;

package/dist/types-ts4.5/text/nodes/table.d.ts

@@ -0,0 +1,3 @@
+import { NodeReducer } from './';
+declare const table: NodeReducer;
+export default table;

package/dist/types-ts4.5/text/nodes/taskItem.d.ts

@@ -0,0 +1,3 @@
+import { NodeReducer } from './';
+declare const taskItem: NodeReducer;
+export default taskItem;

package/dist/types-ts4.5/text/nodes/unknown.d.ts

@@ -0,0 +1,3 @@
+import { NodeReducer } from './';
+declare const unknown: NodeReducer;
+export default unknown;

package/dist/types-ts4.5/text-serializer.d.ts

@@ -0,0 +1 @@
+export { default as TextSerializer } from './text';

package/dist/types-ts4.5/types/i18n.d.ts

@@ -0,0 +1,5 @@
+export interface MessageDescriptor {
+    id: string;
+    description: string;
+    defaultMessage: string;
+}

package/dist/types-ts4.5/types/mediaOptions.d.ts

@@ -0,0 +1,13 @@
+import type { MediaClientConfig } from '@atlaskit/media-core';
+import type { MediaFeatureFlags, SSR } from '@atlaskit/media-common';
+export type MediaSSR = {
+    mode: SSR;
+    config: MediaClientConfig;
+};
+export interface MediaOptions {
+    allowLinking?: boolean;
+    enableDownloadButton?: boolean;
+    featureFlags?: MediaFeatureFlags;
+    ssr?: MediaSSR;
+    allowCaptions?: boolean;
+}

package/dist/types-ts4.5/types/smartLinksOptions.d.ts

@@ -0,0 +1,7 @@
+import type { CardProps } from '@atlaskit/smart-card';
+export interface SmartLinksOptions {
+    ssr?: boolean;
+    showAuthTooltip?: boolean;
+    showServerActions?: boolean;
+    frameStyle?: CardProps['frameStyle'];
+}

package/dist/types-ts4.5/ui/Expand.d.ts

@@ -0,0 +1,23 @@
+/** @jsx jsx */
+import React from 'react';
+import { AnalyticsEventPayload } from '../analytics/events';
+import { WrappedComponentProps } from 'react-intl-next';
+import { RendererAppearance } from './Renderer/types';
+export type StyleProps = {
+    expanded?: boolean;
+    focused?: boolean;
+    'data-node-type'?: 'expand' | 'nestedExpand';
+    'data-title'?: string;
+};
+export interface ExpandProps {
+    title: string;
+    nodeType: 'expand' | 'nestedExpand';
+    children: React.ReactNode;
+    fireAnalyticsEvent?: (event: AnalyticsEventPayload) => void;
+    nestedHeaderIds?: Array<string>;
+    rendererAppearance?: RendererAppearance;
+}
+declare const _default: React.FC<import("react-intl-next").WithIntlProps<ExpandProps & WrappedComponentProps<"intl">>> & {
+    WrappedComponent: React.ComponentType<ExpandProps & WrappedComponentProps<"intl">>;
+};
+export default _default;

package/dist/types-ts4.5/ui/ExtensionRenderer.d.ts

@@ -0,0 +1,42 @@
+import React from 'react';
+import { RendererContext } from '../react/types';
+import { ExtensionLayout } from '@atlaskit/adf-schema';
+import { getNodeRenderer } from '@atlaskit/editor-common/extensions';
+import type { ExtensionHandlers, ExtensionProvider } from '@atlaskit/editor-common/extensions';
+import { ProviderFactory } from '@atlaskit/editor-common/provider-factory';
+import { Mark as PMMark } from '@atlaskit/editor-prosemirror/model';
+export interface Props {
+    type: 'extension' | 'inlineExtension' | 'bodiedExtension';
+    extensionHandlers?: ExtensionHandlers;
+    providers?: ProviderFactory;
+    rendererContext: RendererContext;
+    extensionType: string;
+    extensionKey: string;
+    text?: string;
+    parameters?: any;
+    content?: any;
+    layout?: ExtensionLayout;
+    localId?: string;
+    marks?: PMMark[];
+    children: ({ result }: {
+        result?: JSX.Element | null;
+    }) => JSX.Element;
+}
+export interface State {
+    extensionProvider?: ExtensionProvider | null;
+}
+export default class ExtensionRenderer extends React.Component<Props, State> {
+    state: {
+        extensionProvider: null;
+    };
+    mounted: boolean;
+    UNSAFE_componentWillMount(): void;
+    componentWillUnmount(): void;
+    handleProvider: (name: keyof State, providerPromise?: Promise<any>) => void;
+    getNodeRenderer: import("memoize-one").MemoizedFn<typeof getNodeRenderer>;
+    renderExtensionNode: (extensionProvider?: ExtensionProvider | null) => JSX.Element;
+    setupAndRenderExtensionNode: (providers: {
+        extensionProvider?: Promise<ExtensionProvider<any>> | undefined;
+    }) => JSX.Element;
+    render(): JSX.Element;
+}

package/dist/types-ts4.5/ui/MediaCard.d.ts

@@ -0,0 +1,79 @@
+import React, { Component } from 'react';
+import type { ADFEntity } from '@atlaskit/adf-utils/types';
+import type { CardAppearance, CardDimensions, CardOnClickCallback, NumericalCardDimensions } from '@atlaskit/media-card';
+import type { MediaClientConfig } from '@atlaskit/media-core';
+import type { ImageResizeMode, Identifier, FileState } from '@atlaskit/media-client';
+import type { MediaType } from '@atlaskit/adf-schema';
+import type { ContextIdentifierProvider } from '@atlaskit/editor-common/provider-factory';
+import type { ImageStatus } from '@atlaskit/editor-common/utils';
+import type { MediaFeatureFlags } from '@atlaskit/media-common';
+import type { RendererAppearance } from './Renderer/types';
+import type { RendererContext } from '../react/types';
+import type { MediaSSR } from '../types/mediaOptions';
+export type MediaProvider = {
+    viewMediaClientConfig: MediaClientConfig;
+};
+export interface MediaCardProps {
+    id?: string;
+    mediaProvider?: Promise<MediaProvider>;
+    contextIdentifierProvider?: Promise<ContextIdentifierProvider>;
+    eventHandlers?: {
+        media?: {
+            onClick?: CardOnClickCallback;
+        };
+    };
+    shouldOpenMediaViewer?: boolean;
+    type: MediaType;
+    collection?: string;
+    url?: string;
+    cardDimensions?: CardDimensions;
+    originalDimensions?: NumericalCardDimensions;
+    resizeMode?: ImageResizeMode;
+    appearance?: CardAppearance;
+    rendererAppearance?: RendererAppearance;
+    occurrenceKey?: string;
+    imageStatus?: ImageStatus;
+    disableOverlay?: boolean;
+    useInlinePlayer?: boolean;
+    rendererContext?: RendererContext;
+    alt?: string;
+    featureFlags?: MediaFeatureFlags;
+    shouldEnableDownloadButton?: boolean;
+    ssr?: MediaSSR;
+}
+export interface State {
+    mediaClientConfig?: MediaClientConfig;
+    contextIdentifierProvider?: ContextIdentifierProvider;
+    fileState?: FileState;
+}
+export declare const mediaIdentifierMap: Map<string, Identifier>;
+export declare const getListOfIdentifiersFromDoc: (doc?: ADFEntity) => Identifier[];
+export declare class MediaCardInternal extends Component<MediaCardProps, State> {
+    state: State;
+    componentDidMount(): Promise<void>;
+    UNSAFE_componentWillReceiveProps(newProps: MediaCardProps): void;
+    componentWillUnmount(): void;
+    saveFileState: (id: string, mediaClientConfig: MediaClientConfig) => Promise<void>;
+    private renderLoadingCard;
+    private renderExternal;
+    /**
+     * We want to call provided `eventHandlers.media.onClick` when it's provided,
+     * but we also don't want to call it when it's a video and inline video player is enabled.
+     * This is due to consumers normally process this onClick call by opening media viewer and
+     * we don't want that to happened described above text.
+     */
+    private getOnCardClickCallback;
+    render(): JSX.Element | null;
+}
+export type ClipboardAttrs = {
+    id: string;
+    alt?: string;
+    collection?: string;
+    contextIdentifierProvider?: ContextIdentifierProvider;
+    originalDimensions?: NumericalCardDimensions;
+    fileState?: FileState;
+};
+export declare const getClipboardAttrs: ({ id, alt, collection, contextIdentifierProvider, originalDimensions, fileState, }: ClipboardAttrs) => {
+    [key: string]: string | number | undefined;
+};
+export declare const MediaCard: React.ComponentClass<MediaCardProps & import("@atlaskit/editor-common/utils").ImageLoaderProps, any>;

package/dist/types-ts4.5/ui/Renderer/ErrorBoundary.d.ts

@@ -0,0 +1,24 @@
+import React from 'react';
+import type { CreateUIAnalyticsEvent } from '@atlaskit/analytics-next';
+import type { ComponentCrashErrorAEP } from '../../analytics/events';
+interface ErrorBoundaryProps {
+    component: ComponentCrashErrorAEP['actionSubject'];
+    componentId?: ComponentCrashErrorAEP['actionSubjectId'];
+    fallbackComponent?: React.ReactNode;
+    createAnalyticsEvent?: CreateUIAnalyticsEvent;
+    rethrowError?: boolean;
+}
+interface ErrorBoundaryState {
+    errorCaptured: boolean;
+}
+export declare class ErrorBoundary extends React.Component<ErrorBoundaryProps, ErrorBoundaryState> {
+    state: {
+        errorCaptured: boolean;
+    };
+    private fireAnalyticsEvent;
+    private hasFallback;
+    private shouldRecover;
+    componentDidCatch(error: Error, errorInfo: React.ErrorInfo): void;
+    render(): React.ReactNode;
+}
+export {};

package/dist/types-ts4.5/ui/Renderer/breakout-ssr.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="react" />
+/**
+ * Inline Script that updates breakout node width on client side,
+ * before main JavaScript bundle is ready.
+ *
+ * More info: https://product-fabric.atlassian.net/wiki/spaces/E/pages/1216218119/Renderer+SSR+for+Breakout+Nodes
+ */
+export declare function BreakoutSSRInlineScript(): JSX.Element | null;
+export declare function createBreakoutInlineScript(id: number): string;
+export declare const breakoutInlineScriptContext: string;
+export declare const calcLineLength: any;

package/dist/types-ts4.5/ui/Renderer/click-to-edit.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Check if an element is interactive (or otherwise if clicking on it shouldn't transition the
+ * renderer to the editor in somewhere like the Jira description
+ * @param element
+ */
+export declare function isInteractiveElement(element: HTMLElement | HTMLLinkElement): boolean;

package/dist/types-ts4.5/ui/Renderer/index.d.ts

@@ -0,0 +1,38 @@
+import { jsx } from '@emotion/react';
+import { PureComponent } from 'react';
+import type { RendererProps } from '../renderer-props';
+export declare const NORMAL_SEVERITY_THRESHOLD = 2000;
+export declare const DEGRADED_SEVERITY_THRESHOLD = 3000;
+export interface Extension<T> {
+    extensionKey: string;
+    parameters?: T;
+    content?: any;
+}
+export type { RendererProps as Props };
+export declare class Renderer extends PureComponent<RendererProps> {
+    private providerFactory;
+    private serializer;
+    private editorRef;
+    private rafID?;
+    private mouseDownSelection?;
+    private id?;
+    /**
+     * This is used in measuring the Renderer Mount time and is then
+     * deleted once that measurement occurs.
+     */
+    private renderedMeasurementDistortedDurationMonitor?;
+    constructor(props: RendererProps);
+    private anchorLinkAnalytics;
+    componentDidMount(): void;
+    UNSAFE_componentWillReceiveProps(nextProps: RendererProps): void;
+    private deriveSerializerProps;
+    private featureFlags;
+    private fireAnalyticsEvent;
+    private getSchema;
+    private onMouseDownEditView;
+    private handleMouseTripleClickInTables;
+    render(): jsx.JSX.Element;
+    componentWillUnmount(): void;
+}
+declare const RendererWithAnnotationSelection: (props: RendererProps) => jsx.JSX.Element;
+export default RendererWithAnnotationSelection;

package/dist/types-ts4.5/ui/Renderer/style.d.ts

@@ -0,0 +1,16 @@
+import type { Theme } from '@emotion/react';
+import type { RendererAppearance } from './types';
+export declare const FullPagePadding = 32;
+export type RendererWrapperProps = {
+    appearance?: RendererAppearance;
+    allowNestedHeaderLinks: boolean;
+    allowColumnSorting: boolean;
+    useBlockRenderForCodeBlock: boolean;
+};
+export declare const TELEPOINTER_ID = "ai-streaming-telepointer";
+export declare const headingSizes: {
+    [key: string]: {
+        [key: string]: number;
+    };
+};
+export declare const rendererStyles: (wrapperProps: RendererWrapperProps) => (theme: Theme) => import("@emotion/react").SerializedStyles;

package/dist/types-ts4.5/ui/Renderer/truncated-wrapper.d.ts

@@ -0,0 +1,12 @@
+/** @jsx jsx */
+import { jsx } from '@emotion/react';
+import { Component } from 'react';
+export interface TruncatedWrapperProps {
+    height?: number;
+    fadeHeight?: number;
+    backgroundColor?: string;
+}
+export declare class TruncatedWrapper extends Component<TruncatedWrapperProps, {}> {
+    constructor(props: TruncatedWrapperProps);
+    render(): jsx.JSX.Element;
+}

package/dist/types-ts4.5/ui/Renderer/types.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="react" />
+export type RendererAppearance = 'comment' | 'full-page' | 'full-width' | 'mobile' | undefined;
+export type StickyHeaderConfig = {
+    offsetTop?: number;
+};
+export type StickyHeaderProps = boolean | ({
+    show?: boolean;
+} & StickyHeaderConfig);
+export type HeadingAnchorLinksConfig = {
+    activeHeadingId?: string;
+    allowNestedHeaderLinks?: boolean;
+};
+export type NodeComponentsProps = {
+    [key: string]: React.ComponentType<any>;
+};
+export type HeadingAnchorLinksProps = boolean | HeadingAnchorLinksConfig;

package/dist/types-ts4.5/ui/RendererActionsContext/WithRendererActions.d.ts

@@ -0,0 +1,6 @@
+import { ReactNode } from 'react';
+import RendererActions from '../../actions/index';
+export interface WithRendererActionsProps {
+    render(actions: RendererActions): ReactNode | null;
+}
+export declare function WithRendererActions({ render }: WithRendererActionsProps): JSX.Element;

package/dist/types-ts4.5/ui/RendererActionsContext/index.d.ts

@@ -0,0 +1,9 @@
+import React, { PropsWithChildren } from 'react';
+import RendererActions from '../../actions/index';
+export declare const RendererContext: React.Context<RendererActions>;
+type RendererActionsContextProps = PropsWithChildren<{
+    context?: RendererActions;
+}>;
+export declare function RendererActionsContext({ children, context, }: RendererActionsContextProps): JSX.Element;
+export declare const RendererActionsContextConsumer: React.Consumer<RendererActions>;
+export {};

package/dist/types-ts4.5/ui/SmartCardStorage.d.ts

@@ -0,0 +1,60 @@
+import React from 'react';
+import type { Diff } from '@atlaskit/editor-common/utils';
+export interface WithSmartCardStorageProps {
+    smartCardStorage: Map<string, string>;
+}
+export declare const Context: React.Context<Map<string, string>>;
+export declare const Provider: React.FunctionComponent;
+export declare const withSmartCardStorage: <Props extends WithSmartCardStorageProps>(WrappedComponent: React.ComponentType<Props>) => {
+    new (props: Diff<Props, WithSmartCardStorageProps> | Readonly<Diff<Props, WithSmartCardStorageProps>>): {
+        render(): JSX.Element;
+        context: any;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<Diff<Props, WithSmartCardStorageProps>>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<Diff<Props, WithSmartCardStorageProps>> & Readonly<{
+            children?: React.ReactNode;
+        }>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<Diff<Props, WithSmartCardStorageProps>>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<Diff<Props, WithSmartCardStorageProps>>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<Diff<Props, WithSmartCardStorageProps>>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<Diff<Props, WithSmartCardStorageProps>>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<Diff<Props, WithSmartCardStorageProps>>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<Diff<Props, WithSmartCardStorageProps>>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<Diff<Props, WithSmartCardStorageProps>>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    new (props: Diff<Props, WithSmartCardStorageProps>, context: any): {
+        render(): JSX.Element;
+        context: any;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<Diff<Props, WithSmartCardStorageProps>>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<Diff<Props, WithSmartCardStorageProps>> & Readonly<{
+            children?: React.ReactNode;
+        }>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<Diff<Props, WithSmartCardStorageProps>>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<Diff<Props, WithSmartCardStorageProps>>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<Diff<Props, WithSmartCardStorageProps>>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<Diff<Props, WithSmartCardStorageProps>>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<Diff<Props, WithSmartCardStorageProps>>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<Diff<Props, WithSmartCardStorageProps>>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<Diff<Props, WithSmartCardStorageProps>>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    contextType?: React.Context<any> | undefined;
+};

package/dist/types-ts4.5/ui/SortingIcon.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="react" />
+import { SortOrder } from '@atlaskit/editor-common/types';
+import type { WrappedComponentProps } from 'react-intl-next';
+export declare enum StatusClassNames {
+    ASC = "sorting-icon-svg__asc",
+    DESC = "sorting-icon-svg__desc",
+    NO_ORDER = "sorting-icon-svg__no_order",
+    SORTING_NOT_ALLOWED = "sorting-icon-svg__not-allowed"
+}
+declare const _default: import("react").FC<import("react-intl-next").WithIntlProps<{
+    isSortingAllowed: boolean;
+    sortOrdered?: SortOrder | undefined;
+    onClick: () => void;
+    onKeyDown: (event: import("react").KeyboardEvent<HTMLElement>) => void;
+} & WrappedComponentProps<"intl">>> & {
+    WrappedComponent: import("react").ComponentType<{
+        isSortingAllowed: boolean;
+        sortOrdered?: SortOrder | undefined;
+        onClick: () => void;
+        onKeyDown: (event: import("react").KeyboardEvent<HTMLElement>) => void;
+    } & WrappedComponentProps<"intl">>;
+};
+export default _default;

package/dist/types-ts4.5/ui/TaskItemsFormatContext/TaskItemsFormatContext.d.ts

@@ -0,0 +1,15 @@
+import React, { ReactNode } from 'react';
+export type TaskItemsDone = boolean | undefined;
+export type TaskItemsStateContext = [
+    TaskItemsDone,
+    React.Dispatch<TaskItemsFormatReducerAction>
+];
+export declare const TaskItemsFormatContext: React.Context<TaskItemsStateContext>;
+export type TaskItemsFormatReducerAction = boolean | undefined;
+export declare function TaskItemsFormatProvider({ children }: {
+    children: ReactNode;
+}): JSX.Element;
+export declare function useTaskItemsFormatContext(): TaskItemsStateContext;
+export declare function TaskItemsFormatConsumer({ children, }: {
+    children: ([isChecked, dispatch]: TaskItemsStateContext) => ReactNode;
+}): JSX.Element;

package/dist/types-ts4.5/ui/TaskItemsFormatContext/index.d.ts

@@ -0,0 +1,2 @@
+export { TaskItemsFormatProvider, TaskItemsFormatConsumer, useTaskItemsFormatContext, } from './TaskItemsFormatContext';
+export type { TaskItemsDone, TaskItemsFormatReducerAction, } from './TaskItemsFormatContext';

package/dist/types-ts4.5/ui/active-header-id-provider.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+declare const Provider: React.Provider<string | undefined>;
+type Props = {
+    nestedHeaderIds: string[];
+    onNestedHeaderIdMatch: () => void;
+};
+/**
+ * We need to expose this abstraction on top of the native Consumer in order to control when
+ * The consumer will get notified when a match has happened. If we use the Consumer directly in
+ * Expand components without this inner state, everytime a new prop comes in, and the `newActiveHeaderId`
+ * is the same as before, we will set the expand to true forever, until the active header id changes.
+ * Thus, the user won't be able to collapse the expand.
+ *
+ * By exposing `onNestedHeaderIdMatch` here we can control when will consumers be notified:
+ * only when a `newActiveHeaderId` comes in from the Provider and the list of header ids includes it.
+ */
+declare const ActiveHeaderIdConsumer: ({ nestedHeaderIds, onNestedHeaderIdMatch, }: Props) => JSX.Element;
+export { Provider as ActiveHeaderIdProvider, ActiveHeaderIdConsumer };

package/dist/types-ts4.5/ui/annotations/context.d.ts

@@ -0,0 +1,27 @@
+import React from 'react';
+import { Position } from './types';
+import type { AnnotationProviders } from '@atlaskit/editor-common/types';
+import { AnnotationMarkStates } from '@atlaskit/adf-schema';
+type ChildrenProps = {
+    applyAnnotationDraftAt: (position: Position) => void;
+    clearAnnotationDraft: () => void;
+};
+export type RenderCallbackType = React.FC<ChildrenProps>;
+type Props = {
+    children: RenderCallbackType;
+};
+type State = {
+    position: Position | null;
+};
+export declare const AnnotationsDraftContext: React.Context<Position | null>;
+export declare const ProvidersContext: React.Context<AnnotationProviders | null | undefined>;
+export declare const InlineCommentsStateContext: React.Context<Record<string, AnnotationMarkStates | null>>;
+export declare class AnnotationsDraftContextWrapper extends React.Component<Props, State> {
+    state: {
+        position: null;
+    };
+    render(): JSX.Element;
+    applyAnnotationDraftAt: (nextPosition: Position) => void;
+    clearAnnotationDraft: () => void;
+}
+export {};

package/dist/types-ts4.5/ui/annotations/draft/component.d.ts

@@ -0,0 +1,20 @@
+/** @jsx jsx */
+import React, { ReactNode } from 'react';
+import { InsertDraftPosition, Position } from '../types';
+export declare const AnnotationDraft: React.FC<{
+    draftPosition: Position;
+}>;
+type ApplyAnnotationsProps = {
+    texts: string[];
+    shouldApplyAnnotationAt: InsertDraftPosition.INSIDE | InsertDraftPosition.START | InsertDraftPosition.END;
+    draftPosition: Position;
+};
+export declare const getAnnotationIndex: (annotationPosition: InsertDraftPosition, fragmentCount: number) => number;
+export declare const applyAnnotationOnText: ({ texts, shouldApplyAnnotationAt, draftPosition, }: ApplyAnnotationsProps) => JSX.Element[];
+type Props = {
+    startPos: number;
+    endPos: number;
+    children: ReactNode;
+};
+export declare const TextWithAnnotationDraft: React.FC<Props>;
+export {};

package/dist/types-ts4.5/ui/annotations/draft/dom.d.ts

@@ -0,0 +1,7 @@
+import { Position } from '../types';
+export declare const dataAttributes: ({ from, to }: Position) => {
+    "data-annotation-draft-mark": boolean;
+    "data-draft-start-at": number;
+    "data-draft-end-at": number;
+};
+export declare const updateWindowSelectionAroundDraft: (pos: Position) => boolean;

package/dist/types-ts4.5/ui/annotations/draft/index.d.ts

@@ -0,0 +1,2 @@
+export { updateWindowSelectionAroundDraft } from './dom';
+export { TextWithAnnotationDraft } from './component';

package/dist/types-ts4.5/ui/annotations/draft/position.d.ts

@@ -0,0 +1,2 @@
+import { InsertDraftPosition, Position, TextPosition } from '../types';
+export declare const calcInsertDraftPositionOnText: ({ start: startTextPosition, end: endTextPosition }: TextPosition, position: Position) => InsertDraftPosition | false;