@atlaskit/editor-common 74.0.0 → 74.1.0

package/dist/types-ts4.5/analytics/types/referentiality-events.d.ts

@@ -0,0 +1,52 @@
+import { ACTION, ACTION_SUBJECT, EVENT_TYPE } from './enums';
+import { OperationalAEP } from './utils';
+export type InitialiseFragmentMarksAEP = OperationalAEP<ACTION.INITIALISED_FRAGMENT_MARK, ACTION_SUBJECT.DOCUMENT, undefined, {
+    duration: number;
+    docSize: number;
+    count: number;
+}, EVENT_TYPE.OPERATIONAL>;
+export type ConnectedNodesAEP = OperationalAEP<ACTION.CONNECTED_NODES, ACTION_SUBJECT.DOCUMENT, undefined, {
+    actionType: string;
+    docSize: number;
+    duration: number;
+    sourceNodeType: string;
+    targetNodeType: string;
+    type: string;
+}, EVENT_TYPE.OPERATIONAL>;
+export type DisconnectedSourceAEP = OperationalAEP<ACTION.DISCONNECTED_SOURCE, ACTION_SUBJECT.DOCUMENT, undefined, {
+    docSize: number;
+    duration: number;
+    targetNodeType: string;
+}, EVENT_TYPE.OPERATIONAL>;
+export type DisconnectedTargetAEP = OperationalAEP<ACTION.DISCONNECTED_TARGET, ACTION_SUBJECT.DOCUMENT, undefined, {
+    docSize: number;
+    duration: number;
+    sourceNodeType: string;
+    targetNodeType: string;
+}, EVENT_TYPE.OPERATIONAL>;
+export type GotConnectionsAEP = OperationalAEP<ACTION.GOT_CONNECTIONS, ACTION_SUBJECT.DOCUMENT, undefined, {
+    count: number;
+    docSize: number;
+    duration: number;
+}, EVENT_TYPE.OPERATIONAL>;
+export type UpdatedFragmentMarkNameAEP = OperationalAEP<ACTION.UPDATED_FRAGMENT_MARK_NAME, ACTION_SUBJECT.DOCUMENT, undefined, {
+    duration: number;
+    nodeType: string;
+}, EVENT_TYPE.OPERATIONAL>;
+export type UpdatedSourceAEP = OperationalAEP<ACTION.UPDATED_SOURCE, ACTION_SUBJECT.DOCUMENT, undefined, {
+    docSize: number;
+    duration: number;
+    newSourceNodeType: string;
+    oldSourceNodeType: string;
+    type: UPDATED_TYPE;
+}, EVENT_TYPE.OPERATIONAL>;
+export type UPDATED_TYPE = 'update' | 'replaceAndUpdate';
+export type UpdatedTargetAEP = OperationalAEP<ACTION.UPDATED_TARGET, ACTION_SUBJECT.DOCUMENT, undefined, {
+    docSize: number;
+    duration: number;
+    newTargetNodeType: string;
+    oldTargetNodeType: string;
+    sourceNodeType: string;
+    type: UPDATED_TYPE;
+}, EVENT_TYPE.OPERATIONAL>;
+export type ReferentialityEventPayload = InitialiseFragmentMarksAEP | ConnectedNodesAEP | DisconnectedSourceAEP | DisconnectedTargetAEP | GotConnectionsAEP | UpdatedFragmentMarkNameAEP | UpdatedSourceAEP | UpdatedTargetAEP;

package/dist/types-ts4.5/analytics/types/selection-events.d.ts

@@ -0,0 +1,18 @@
+import type { ACTION, ACTION_SUBJECT, ACTION_SUBJECT_ID } from './enums';
+import type { TrackAEP } from './utils';
+type SelectAEP<ActionSubjectID, Attributes> = TrackAEP<ACTION.SELECTED, ACTION_SUBJECT.DOCUMENT, ActionSubjectID, Attributes, undefined>;
+export type SelectNodeAEP = SelectAEP<ACTION_SUBJECT_ID.NODE, {
+    node: string;
+}>;
+export type SelectRangeAEP = SelectAEP<ACTION_SUBJECT_ID.RANGE, {
+    nodes: string[];
+    from: number;
+    to: number;
+}>;
+export type SelectAllAEP = SelectAEP<ACTION_SUBJECT_ID.ALL, undefined>;
+export type SelectCellAEP = SelectAEP<ACTION_SUBJECT_ID.CELL, {
+    selectedCells: number;
+    totalCells: number;
+}>;
+export type SelectionEventPayload = SelectNodeAEP | SelectRangeAEP | SelectAllAEP | SelectCellAEP;
+export {};

package/dist/types-ts4.5/analytics/types/smart-links.d.ts

@@ -0,0 +1,14 @@
+import type { ACTION_SUBJECT_ID, INPUT_METHOD } from './enums';
+import type { InsertAEP } from './utils';
+export type SmartLinkNodeContext = 'doc' | 'blockquote' | 'tableCell' | 'tableHeader' | 'decisionList' | 'listItem' | 'bodiedExtension' | 'panel' | 'taskList' | 'mixed';
+export declare const SmartLinkNodeContexts: {
+    [P in SmartLinkNodeContext]: P;
+};
+export type InsertSmartLinkAEP = InsertAEP<ACTION_SUBJECT_ID.SMART_LINK, {
+    inputMethod: INPUT_METHOD.CLIPBOARD | INPUT_METHOD.AUTO_DETECT | INPUT_METHOD.TYPEAHEAD | INPUT_METHOD.MANUAL | INPUT_METHOD.FORMATTING | INPUT_METHOD.FLOATING_TB;
+    nodeType: 'inlineCard' | 'blockCard' | 'embedCard';
+    nodeContext: SmartLinkNodeContext;
+    fromCurrentDomain: boolean;
+}, {
+    domainName: string;
+}>;

package/dist/types-ts4.5/analytics/types/substitute-events.d.ts

@@ -0,0 +1,26 @@
+import type { ACTION, ACTION_SUBJECT, ACTION_SUBJECT_ID } from './enums';
+import type { TrackAEP } from './utils';
+export declare enum SYMBOL {
+    ARROW_RIGHT = "rightArrow",
+    ARROW_LEFT = "leftArrow",
+    ARROW_DOUBLE = "doubleArrow"
+}
+export declare enum PUNC {
+    DASH = "emDash",
+    ELLIPSIS = "ellipsis",
+    QUOTE_SINGLE = "singleQuote",
+    QUOTE_DOUBLE = "doubleQuote"
+}
+type SubstituteAEP<ActionSubjectID, Attributes> = TrackAEP<ACTION.SUBSTITUTED, ACTION_SUBJECT.TEXT, ActionSubjectID, Attributes, undefined>;
+type SubstituteProductAEP = SubstituteAEP<ACTION_SUBJECT_ID.PRODUCT_NAME, {
+    product: string;
+    originalSpelling: string;
+}>;
+type SubstituteSymbolAEP = SubstituteAEP<ACTION_SUBJECT_ID.SYMBOL, {
+    symbol: SYMBOL.ARROW_RIGHT | SYMBOL.ARROW_LEFT | SYMBOL.ARROW_DOUBLE;
+}>;
+type SubstitutePuncAEP = SubstituteAEP<ACTION_SUBJECT_ID.PUNC, {
+    punctuation: PUNC.DASH | PUNC.ELLIPSIS | PUNC.QUOTE_SINGLE | PUNC.QUOTE_DOUBLE;
+}>;
+export type SubstituteEventPayload = SubstituteProductAEP | SubstituteSymbolAEP | SubstitutePuncAEP;
+export {};

package/dist/types-ts4.5/analytics/types/table-events.d.ts

@@ -0,0 +1,102 @@
+import type { TableSortOrder as SortOrder } from '@atlaskit/adf-schema/steps';
+import type { ACTION_SUBJECT, INPUT_METHOD } from './enums';
+import type { TableAEP, UIAEP } from './utils';
+export declare enum TABLE_ACTION {
+    DELETED = "deleted",
+    CLEARED = "cleared",
+    COLLAPSED = "collapsed",
+    MERGED = "merged",
+    SPLIT = "split",
+    COLORED = "colored",
+    TOGGLED_HEADER_COLUMN = "toggledHeaderColumn",
+    TOGGLED_HEADER_ROW = "toggledHeaderRow",
+    TOGGLED_NUMBER_COLUMN = "toggledNumberColumn",
+    CHANGED_BREAKOUT_MODE = "changedBreakoutMode",
+    CUT = "cut",
+    COPIED = "copied",
+    ADDED_ROW = "addedRow",
+    ADDED_COLUMN = "addedColumn",
+    DELETED_ROW = "deletedRow",
+    DELETED_COLUMN = "deletedColumn",
+    SORTED_COLUMN = "sortedColumn",
+    REPLACED = "replaced",
+    ATTEMPTED_TABLE_WIDTH_CHANGE = "attemptedTableWidthChange",
+    DISTRIBUTED_COLUMNS_WIDTHS = "distributedColumnsWidths",
+    FIXED = "fixed"
+}
+export declare enum TABLE_BREAKOUT {
+    WIDE = "wide",
+    FULL_WIDTH = "fullWidth",
+    NORMAL = "normal"
+}
+interface SortColumn {
+    sortOrder: SortOrder;
+    mode: 'editor';
+}
+interface TotalRowAndColCount {
+    totalRowCount: number;
+    totalColumnCount: number;
+}
+interface HorizontalAndVerticalCells {
+    horizontalCells: number;
+    verticalCells: number;
+}
+type AllCellInfo = TotalRowAndColCount & HorizontalAndVerticalCells & {
+    totalCells: number;
+};
+type AttemptedResizeInfo = {
+    type: string;
+    position: string;
+    duration: number;
+    delta: number;
+};
+type TableDeleteAEP = TableAEP<TABLE_ACTION.DELETED, {
+    inputMethod: INPUT_METHOD.KEYBOARD | INPUT_METHOD.FLOATING_TB;
+} & TotalRowAndColCount, undefined>;
+type TableClearAEP = TableAEP<TABLE_ACTION.CLEARED, {
+    inputMethod: INPUT_METHOD.KEYBOARD | INPUT_METHOD.CONTEXT_MENU | INPUT_METHOD.FLOATING_TB;
+} & HorizontalAndVerticalCells & TotalRowAndColCount, undefined>;
+type TableMergeSplitAEP = TableAEP<TABLE_ACTION.MERGED | TABLE_ACTION.SPLIT, {
+    inputMethod: INPUT_METHOD.CONTEXT_MENU | INPUT_METHOD.FLOATING_TB;
+} & AllCellInfo, undefined>;
+type TableColorAEP = TableAEP<TABLE_ACTION.COLORED, {
+    inputMethod: INPUT_METHOD.CONTEXT_MENU | INPUT_METHOD.FLOATING_TB;
+} & {
+    cellColor: string;
+} & AllCellInfo, undefined>;
+type TableToggleHeaderAEP = TableAEP<TABLE_ACTION.TOGGLED_NUMBER_COLUMN | TABLE_ACTION.TOGGLED_HEADER_ROW | TABLE_ACTION.TOGGLED_HEADER_COLUMN, {
+    newState: boolean;
+} & TotalRowAndColCount, undefined>;
+type TableChangeBreakoutAEP = TableAEP<TABLE_ACTION.CHANGED_BREAKOUT_MODE, {
+    newBreakoutMode: TABLE_BREAKOUT;
+    previousBreakoutMode: TABLE_BREAKOUT;
+} & TotalRowAndColCount, undefined>;
+type TableCopyAndCutAEP = TableAEP<TABLE_ACTION.CUT | TABLE_ACTION.COPIED, AllCellInfo, undefined>;
+type TableAddRowOrColumnAEP = TableAEP<TABLE_ACTION.ADDED_ROW | TABLE_ACTION.ADDED_COLUMN, {
+    inputMethod: INPUT_METHOD.SHORTCUT | INPUT_METHOD.CONTEXT_MENU | INPUT_METHOD.BUTTON | INPUT_METHOD.KEYBOARD | INPUT_METHOD.FLOATING_TB;
+    position: number;
+} & TotalRowAndColCount, undefined>;
+type TableDeleteRowOrColumnAEP = TableAEP<TABLE_ACTION.DELETED_ROW | TABLE_ACTION.DELETED_COLUMN, {
+    inputMethod: INPUT_METHOD.CONTEXT_MENU | INPUT_METHOD.BUTTON | INPUT_METHOD.FLOATING_TB;
+    position: number;
+    count: number;
+} & TotalRowAndColCount, undefined>;
+type TableDistributeColumnsWidthsAEP = TableAEP<TABLE_ACTION.DISTRIBUTED_COLUMNS_WIDTHS, {
+    inputMethod: INPUT_METHOD.CONTEXT_MENU | INPUT_METHOD.FLOATING_TB;
+    position: number;
+    count: number;
+} & TotalRowAndColCount, undefined>;
+type TableSortColumnAEP = TableAEP<TABLE_ACTION.SORTED_COLUMN, {
+    inputMethod: INPUT_METHOD.SHORTCUT | INPUT_METHOD.CONTEXT_MENU | INPUT_METHOD.BUTTON | INPUT_METHOD.FLOATING_TB | INPUT_METHOD.KEYBOARD;
+    position: number;
+} & TotalRowAndColCount & SortColumn, undefined>;
+type TableReplaceAEP = TableAEP<TABLE_ACTION.REPLACED, {
+    inputMethod: INPUT_METHOD.KEYBOARD | INPUT_METHOD.CLIPBOARD;
+} & TotalRowAndColCount, undefined>;
+type TableAttemptedResizeAEP = UIAEP<TABLE_ACTION.ATTEMPTED_TABLE_WIDTH_CHANGE, ACTION_SUBJECT.TABLE, null, AttemptedResizeInfo, undefined>;
+type TableCollapsedAEP = TableAEP<TABLE_ACTION.COLLAPSED, TotalRowAndColCount, undefined>;
+type TableFixedAEP = TableAEP<TABLE_ACTION.FIXED, {
+    reason: string;
+}, undefined>;
+export type TableEventPayload = TableDeleteAEP | TableClearAEP | TableMergeSplitAEP | TableColorAEP | TableToggleHeaderAEP | TableChangeBreakoutAEP | TableCopyAndCutAEP | TableAddRowOrColumnAEP | TableSortColumnAEP | TableDeleteRowOrColumnAEP | TableReplaceAEP | TableAttemptedResizeAEP | TableDistributeColumnsWidthsAEP | TableCollapsedAEP | TableFixedAEP;
+export {};

package/dist/types-ts4.5/analytics/types/toolbar-button.d.ts

@@ -0,0 +1,22 @@
+import type { ACTION, ACTION_SUBJECT } from './enums';
+import type { UIAEP } from './utils';
+export declare enum TOOLBAR_ACTION_SUBJECT_ID {
+    FIND_REPLACE = "findReplace",
+    EMOJI = "emoji",
+    ORDERED_LIST = "orderedList",
+    BULLET_LIST = "bulletList",
+    MEDIA = "media",
+    MENTION = "mention",
+    DECISION_LIST = "decisionList",
+    TASK_LIST = "taskList",
+    TEXT_COLOR = "color",
+    TEXT_FORMATTING_STRONG = "strong",
+    TEXT_FORMATTING_ITALIC = "italic",
+    UNDO = "undo",
+    REDO = "redo",
+    INDENT = "indent",
+    OUTDENT = "outdent"
+}
+type ToolbarButtonClickedAEP = UIAEP<ACTION.CLICKED, ACTION_SUBJECT.TOOLBAR_BUTTON, undefined, {}, undefined>;
+export type ToolbarEventPayload = ToolbarButtonClickedAEP;
+export {};

package/dist/types-ts4.5/analytics/types/type-ahead.d.ts

@@ -0,0 +1,27 @@
+import type { TypeAheadAvailableNodes } from '../../type-ahead';
+import type { ACTION, ACTION_SUBJECT, ACTION_SUBJECT_ID, INPUT_METHOD } from './enums';
+import type { OperationalAEP, UIAEP } from './utils';
+type TypeAheadRenderedAEP = OperationalAEP<ACTION.RENDERED, ACTION_SUBJECT.TYPEAHEAD, undefined, {
+    time?: number;
+    items?: number;
+    initial?: boolean;
+}, undefined>;
+type TypeAheadItemViewedAEP = OperationalAEP<ACTION.VIEWED, ACTION_SUBJECT.TYPEAHEAD_ITEM, undefined, {
+    index?: number;
+    items?: number;
+}, undefined>;
+type TypeAheadAEP<ActionSubjectID, Attributes> = UIAEP<ACTION.INVOKED, ACTION_SUBJECT.TYPEAHEAD, ActionSubjectID, Attributes, undefined>;
+type TypeAheadEmojiAEP = TypeAheadAEP<ACTION_SUBJECT_ID.TYPEAHEAD_EMOJI | TypeAheadAvailableNodes.EMOJI, {
+    inputMethod: INPUT_METHOD.TOOLBAR | INPUT_METHOD.INSERT_MENU | INPUT_METHOD.QUICK_INSERT | INPUT_METHOD.KEYBOARD;
+}>;
+type TypeAheadLinkAEP = TypeAheadAEP<ACTION_SUBJECT_ID.TYPEAHEAD_LINK, {
+    inputMethod: INPUT_METHOD.TOOLBAR | INPUT_METHOD.INSERT_MENU | INPUT_METHOD.QUICK_INSERT | INPUT_METHOD.SHORTCUT;
+}>;
+type TypeAheadMentionAEP = TypeAheadAEP<ACTION_SUBJECT_ID.TYPEAHEAD_MENTION | TypeAheadAvailableNodes.MENTION, {
+    inputMethod: INPUT_METHOD.TOOLBAR | INPUT_METHOD.INSERT_MENU | INPUT_METHOD.QUICK_INSERT | INPUT_METHOD.KEYBOARD;
+}>;
+type TypeAheadQuickInsertAEP = TypeAheadAEP<ACTION_SUBJECT_ID.TYPEAHEAD_QUICK_INSERT | TypeAheadAvailableNodes.QUICK_INSERT, {
+    inputMethod: INPUT_METHOD.TOOLBAR | INPUT_METHOD.INSERT_MENU | INPUT_METHOD.QUICK_INSERT | INPUT_METHOD.KEYBOARD;
+}>;
+export type TypeAheadPayload = TypeAheadEmojiAEP | TypeAheadLinkAEP | TypeAheadMentionAEP | TypeAheadQuickInsertAEP | TypeAheadRenderedAEP | TypeAheadItemViewedAEP;
+export {};

package/dist/types-ts4.5/analytics/types/utils.d.ts

@@ -0,0 +1,46 @@
+import type { ACTION, ACTION_SUBJECT, EVENT_TYPE } from './enums';
+type AEP<Action, ActionSubject, ActionSubjectID, Attributes, NonPrivacySafeAttributes, EventType, ImplicitAttributes extends {} = {}> = {
+    action: Action;
+    actionSubject: ActionSubject;
+    actionSubjectId?: ActionSubjectID;
+    attributes?: Attributes & {
+        [key in keyof ImplicitAttributes]?: ImplicitAttributes[key];
+    };
+    eventType: EventType;
+    nonPrivacySafeAttributes?: NonPrivacySafeAttributes;
+};
+export type UIAEP<Action, ActionSubject, ActionSubjectID, Attributes, NonPrivacySafeAttributes> = AEP<Action, ActionSubject, ActionSubjectID, Attributes, NonPrivacySafeAttributes, EVENT_TYPE.UI>;
+export type TrackAEP<Action, ActionSubject, ActionSubjectID, Attributes, NonPrivacySafeAttributes, ImplicitAttributes extends {} = {}> = AEP<Action, ActionSubject, ActionSubjectID, Attributes, NonPrivacySafeAttributes, EVENT_TYPE.TRACK, ImplicitAttributes>;
+export type OperationalAEP<Action, ActionSubject, ActionSubjectID, Attributes, NonPrivacySafeAttributes> = AEP<Action, ActionSubject, ActionSubjectID, Attributes, NonPrivacySafeAttributes, EVENT_TYPE.OPERATIONAL>;
+export type OperationalExposureAEP<Action, ActionSubject, ActionSubjectID, Attributes> = OperationalAEP<Action, ActionSubject, ActionSubjectID, Attributes, {}> & {
+    source?: string;
+    tags?: string[];
+};
+export type OperationalAEPWithObjectId<Action, ActionSubject, ActionSubjectID, Attributes, NonPrivacySafeAttributes> = OperationalAEP<Action, ActionSubject, ActionSubjectID, Attributes & {
+    objectId?: string;
+}, NonPrivacySafeAttributes>;
+export type ScreenAEP<Action, ActionSubject, ActionSubjectID, Attributes, NonPrivacySafeAttributes> = AEP<Action, ActionSubject, ActionSubjectID, Attributes, NonPrivacySafeAttributes, EVENT_TYPE.SCREEN>;
+export type TableAEP<Action, Attributes, NonPrivacySafeAttributes> = TrackAEP<Action, ACTION_SUBJECT.TABLE, null, Attributes, NonPrivacySafeAttributes>;
+export declare enum SELECTION_TYPE {
+    CURSOR = "cursor",
+    RANGED = "ranged",
+    TEXT = "text",
+    NODE = "node",
+    CELL = "cell",
+    GAP_CURSOR = "gapCursor"
+}
+export declare enum SELECTION_POSITION {
+    START = "start",
+    MIDDLE = "middle",
+    END = "end",
+    LEFT = "left",
+    RIGHT = "right"
+}
+interface NonRequiredAttributes {
+    insertLocation?: string;
+    nodeLocation?: string;
+    selectionType?: SELECTION_TYPE;
+    selectionPosition?: SELECTION_POSITION;
+}
+export type InsertAEP<ActionSubjectID, Attributes, NonPrivacySafeAttributes> = TrackAEP<ACTION.INSERTED, ACTION_SUBJECT.DOCUMENT, ActionSubjectID, Attributes, NonPrivacySafeAttributes, NonRequiredAttributes>;
+export {};

package/dist/types-ts4.5/analytics/utils.d.ts

@@ -0,0 +1,3 @@
+import { ReadonlyTransaction, Transaction } from 'prosemirror-state';
+import { AnalyticsEventPayloadWithChannel } from './types';
+export declare function getAnalyticsEventsFromTransaction(tr: Transaction | ReadonlyTransaction): AnalyticsEventPayloadWithChannel[];

package/dist/types-ts4.5/card/cardOptions.d.ts

@@ -0,0 +1,12 @@
+import { Providers } from '../provider-factory';
+export interface CardOptions {
+    provider?: Providers['cardProvider'];
+    resolveBeforeMacros?: string[];
+    allowBlockCards?: boolean;
+    allowEmbeds?: boolean;
+    allowResizing?: boolean;
+    showServerActions?: boolean;
+    useAlternativePreloader?: boolean;
+    allowAlignment?: boolean;
+    allowWrapping?: boolean;
+}

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

@@ -0,0 +1,2 @@
+export type { CardOptions } from './cardOptions';
+export { addLinkMetadata, getLinkMetadataFromTransaction, commandWithMetadata, } from './utils';

package/dist/types-ts4.5/card/utils.d.ts

@@ -0,0 +1,18 @@
+import { EditorState, ReadonlyTransaction, Selection, Transaction } from 'prosemirror-state';
+import { EditorView } from 'prosemirror-view';
+import { LinkStepMetadata } from '@atlaskit/adf-schema/steps';
+/**
+ * Records metadata about the user action and input method relating to a transaction
+ * as a custom LinkStepMetadata prosemirror step so that it is preserved in
+ * the history for undo/redo
+ */
+export declare function addLinkMetadata(initialSelection: Selection, tr: Transaction, metadata: LinkStepMetadata): Transaction<any>;
+export declare function getLinkMetadataFromTransaction(tr: Transaction | ReadonlyTransaction): LinkStepMetadata;
+export type CommandDispatch = (tr: Transaction) => void;
+export type Command = (state: EditorState, dispatch?: CommandDispatch, view?: EditorView) => boolean;
+/**
+ * Adds metadata to the transaction created from a command
+ * The metadata describes the user intent and input method
+ * for executing the command
+ */
+export declare const commandWithMetadata: (command: Command, metadata: LinkStepMetadata) => Command;

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

@@ -0,0 +1,101 @@
+import { EditorState, Transaction } from 'prosemirror-state';
+import { Step } from 'prosemirror-transform';
+import { JSONDocNode } from '@atlaskit/editor-json-transformer';
+import { SyncUpErrorFunction } from '../types';
+export interface CollabParticipant {
+    lastActive: number;
+    sessionId: string;
+    avatar: string;
+    name: string;
+    cursorPos?: number;
+}
+export interface CollabEventInitData {
+    doc?: any;
+    json?: any;
+    version?: number;
+    sid?: string;
+    reserveCursor?: boolean;
+}
+export interface CollabEventRemoteData {
+    json?: any;
+    newState?: EditorState;
+    userIds?: (number | string)[];
+}
+export interface CollabEventConnectionData {
+    sid: string;
+    initial: boolean;
+}
+export interface CollabEventConnectingData {
+    initial: boolean;
+}
+export interface CollabEventDisconnectedData {
+    sid: string;
+    reason: 'CLIENT_DISCONNECT' | 'SERVER_DISCONNECT' | 'SOCKET_CLOSED' | 'SOCKET_ERROR' | 'SOCKET_TIMEOUT' | 'UNKNOWN_DISCONNECT';
+}
+export interface CollabEventPresenceData {
+    joined?: CollabParticipant[];
+    left?: {
+        sessionId: string;
+    }[];
+}
+/**
+ * @deprecated use CollabTelepointerPayload from "@atlaskit/collab-provider"
+ */
+export interface CollabEventTelepointerData {
+    type: 'telepointer';
+    selection: CollabSendableSelection;
+    sessionId: string;
+}
+export interface CollabEventLocalStepData {
+    steps: Array<Step>;
+}
+/**
+ * @deprecated use CollabSendableSelection from "@atlaskit/collab-provider"
+ */
+export interface CollabSendableSelection {
+    type: 'textSelection' | 'nodeSelection';
+    anchor: number;
+    head: number;
+}
+/**
+ * @deprecated use keyof CollabEvents from "@atlaskit/collab-provider"
+ */
+export type CollabEvent = keyof CollabEventData;
+/**
+ * @deprecated use CollabEvents from "@atlaskit/collab-provider"
+ */
+export interface CollabEventData {
+    init: CollabEventInitData;
+    connected: CollabEventConnectionData;
+    disconnected: CollabEventDisconnectedData;
+    data: CollabEventRemoteData;
+    telepointer: CollabEventTelepointerData;
+    presence: CollabEventPresenceData;
+    error: any;
+    'local-steps': any;
+    entity: any;
+    connecting: CollabEventConnectingData;
+}
+export type ResolvedEditorState<T = any> = {
+    content: JSONDocNode | T;
+    title: string | null;
+    stepVersion: number;
+};
+/**
+ * @deprecated use CollabEditProvider from "@atlaskit/collab-provider"
+ */
+export interface CollabEditProvider<Events extends CollabEventData = CollabEventData> {
+    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>;
+}

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

@@ -0,0 +1 @@
+export type { CollabEditProvider, CollabEventPresenceData, CollabEvent, CollabEventConnectionData, CollabEventDisconnectedData, CollabEventData, CollabEventInitData, CollabEventRemoteData, CollabEventTelepointerData, CollabParticipant, CollabSendableSelection, CollabEventLocalStepData, ResolvedEditorState, CollabEventConnectingData, } from './collab/types';

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 { EditorState } from 'prosemirror-state';
+export declare const insideTable: (state: EditorState) => Boolean;

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

@@ -0,0 +1,3 @@
+export { default as Emoji } from './ui/Emoji';
+export type { EmojiProps } from './ui/Emoji';
+export { EmojiSharedCssClassName } from './styles/shared/emoji';

package/dist/types-ts4.5/event-dispatcher/index.d.ts

@@ -0,0 +1,21 @@
+import { PluginKey } from 'prosemirror-state';
+export interface Listeners {
+    [name: string]: Set<Listener>;
+}
+export type Listener<T = any> = (data: T) => void;
+type EventName = PluginKey | string;
+export type Dispatch<T = any> = (eventName: EventName, data: T) => void;
+export declare class EventDispatcher<T = any> {
+    private listeners;
+    on(event: string, cb: Listener<T>): void;
+    has(event: string, cb: Listener<T>): boolean;
+    off(event: string, cb: Listener<T>): void;
+    emit(event: string, data: T): void;
+    destroy(): void;
+}
+/**
+ * Creates a dispatch function that can be called inside ProseMirror Plugin
+ * to notify listeners about that plugin's state change.
+ */
+export declare function createDispatch<T>(eventDispatcher: EventDispatcher<T>): Dispatch<T>;
+export {};

package/dist/types-ts4.5/extensions/combine-extension-providers.d.ts

@@ -0,0 +1,7 @@
+import { ExtensionProvider } from './types';
+/**
+ * Allow to run methods from the `ExtensionProvider` interface across all providers seamlessly.
+ * Handles promise racing and discards rejected promises safely.
+ */
+declare const _default: (extensionProviders: (ExtensionProvider | Promise<ExtensionProvider>)[]) => ExtensionProvider;
+export default _default;

package/dist/types-ts4.5/extensions/default-extension-provider.d.ts

@@ -0,0 +1,17 @@
+import { ExtensionAutoConvertHandler, ExtensionKey, ExtensionManifest, ExtensionProvider, ExtensionType, Parameters } from './types';
+export default class DefaultExtensionProvider<T extends Parameters> implements ExtensionProvider<T> {
+    private manifestsPromise;
+    private autoConvertHandlers?;
+    constructor(manifests: ExtensionManifest<T>[] | Promise<ExtensionManifest<T>[]>, 
+    /**
+     * Allows for an optional list of pre compiled auto convert handlers to be passed.
+     * Useful for performance improvements or to support legacy converters.
+     *
+     * Warning: If this attribute is passed, this provider will ignore auto convert patterns from the manifests.
+     */
+    autoConvertHandlers?: ExtensionAutoConvertHandler[]);
+    getExtensions(): Promise<ExtensionManifest<T>[]>;
+    getExtension(type: ExtensionType, key: ExtensionKey): Promise<ExtensionManifest<T>>;
+    search(keyword: string): Promise<ExtensionManifest<T>[]>;
+    getAutoConverter(): Promise<ExtensionAutoConvertHandler[]>;
+}

package/dist/types-ts4.5/extensions/extension-fields-helpers.d.ts

@@ -0,0 +1,10 @@
+import { CustomFieldResolver, Deserializer, ExtensionManifest, Serializer, UserFieldContextProvider } from './types/extension-manifest';
+import { FieldHandlerLink } from './types/field-definitions';
+/** attempt to get the custom resolver for this field, or throw */
+export declare function getCustomFieldResolver(manifest: ExtensionManifest, handlerLink: FieldHandlerLink): Promise<CustomFieldResolver>;
+/** attempt to get the serializer for this field, or throw */
+export declare function getFieldSerializer(manifest: ExtensionManifest, handlerLink: FieldHandlerLink): Promise<Serializer | undefined>;
+/** attempt to get the deserializer for this field, or throw */
+export declare function getFieldDeserializer(manifest: ExtensionManifest, handlerLink: FieldHandlerLink): Promise<Deserializer | undefined>;
+/** attempt to get the user field context provider for this field, or throw */
+export declare function getUserFieldContextProvider(manifest: ExtensionManifest, handlerLink: FieldHandlerLink): Promise<UserFieldContextProvider>;

package/dist/types-ts4.5/extensions/extension-handlers.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+import Loadable from 'react-loadable';
+import { ExtensionKey, ExtensionParams, ExtensionProvider, ExtensionType, Parameters } from './types';
+import { ReferenceEntity } from './types/extension-handler';
+export declare function getExtensionModuleNode(extensionProvider: ExtensionProvider, extensionType: ExtensionType, extensionKey: ExtensionKey): Promise<import("./types").ExtensionModuleNode<any>>;
+/**
+ * Gets `__` prefixed properties from an extension node module definition
+ */
+export declare function getExtensionModuleNodePrivateProps(extensionProvider: ExtensionProvider, extensionType: ExtensionType, extensionKey: ExtensionKey): Promise<any>;
+export declare function getNodeRenderer<T extends Parameters>(extensionProvider: ExtensionProvider, extensionType: ExtensionType, extensionKey: ExtensionKey): React.ComponentType<{
+    node: ExtensionParams<T>;
+    references?: ReferenceEntity[] | undefined;
+}> & Loadable.LoadableComponent;

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

@@ -0,0 +1,8 @@
+export { isFieldset, isTabGroup, isTabField, isExpand, isDateRange, } from './types';
+export type { Extension, ExtensionAutoConvertHandler, ExtensionComponentProps, ExtensionHandler, ExtensionHandlers, ExtensionKey, ExtensionManifest, ExtensionModule, ExtensionModuleAction, ExtensionModuleActionHandler, ExtensionModuleActionObject, ExtensionModuleNode, ExtensionModuleNodes, ExtensionModules, ExtensionParams, ExtensionProvider, ExtensionQuickInsertModule, ExtensionType, ExtensionToolbarButton, ContextualToolbar, ToolbarItem, Icon, MaybeADFEntity, MenuItem, MenuItemMap, UpdateExtension, Parameters, ParametersWithDuplicateFields, BooleanField, CustomField, CustomFieldResolver, UserFieldContext, UserField, UserFieldContextProvider, ColorField, DateField, DateRangeField, DateRangeResult, EnumField, EnumCheckboxField, EnumRadioField, EnumSelectField, ExpandField, FieldDefinition, DynamicFieldDefinitions, Fieldset, GroupingField, NativeField, NestedFieldDefinition, NumberField, Option, StringField, StringOneLineField, StringMultilineField, TabGroupField, TabField, FieldHandlerLink, OnSaveCallback, ExtensionAPI, TransformBefore, TransformAfter, ReferenceEntity, ParametersGetter, AsyncParametersGetter, } from './types';
+export { getExtensionKeyAndNodeKey, resolveImport } from './manifest-helpers';
+export { default as DefaultExtensionProvider } from './default-extension-provider';
+export { createAutoConverterRunner, getExtensionAutoConvertersFromProvider, getQuickInsertItemsFromModule, getContextualToolbarItemsFromModule, buildMenuItem, } from './module-helpers';
+export { getExtensionModuleNode, getExtensionModuleNodePrivateProps, getNodeRenderer, } from './extension-handlers';
+export { default as combineExtensionProviders } from './combine-extension-providers';
+export { getCustomFieldResolver, getUserFieldContextProvider, getFieldSerializer, getFieldDeserializer, } from './extension-fields-helpers';

package/dist/types-ts4.5/extensions/manifest-helpers.d.ts

@@ -0,0 +1,9 @@
+import type { ADFEntity } from '@atlaskit/adf-utils/types';
+import { ExtensionKey, ExtensionManifest, ExtensionModuleAction, ExtensionModuleActionObject, ExtensionModuleKey, ExtensionType, Module } from './types/extension-manifest';
+import { Parameters } from './types/extension-parameters';
+export declare const FORGE_EXTENSION_TYPE = "com.atlassian.ecosystem";
+export declare const getExtensionKeyAndNodeKey: (extensionKey: ExtensionKey, extensionType: ExtensionType) => string[];
+export declare const buildExtensionKeyAndNodeKey: (extensionKey: ExtensionKey, nodeKey?: ExtensionModuleKey) => string;
+export declare function buildAction<T extends Parameters>(action: ExtensionModuleAction<T>, manifest: ExtensionManifest<T>): ADFEntity | import("./types/extension-manifest").ExtensionModuleActionHandler | undefined;
+export declare const resolveImport: <T extends Parameters>(importPromise: Module<T>) => Promise<T>;
+export declare function buildNode<T extends Parameters>(action: ExtensionModuleActionObject<T>, manifest: ExtensionManifest<T>): ADFEntity | undefined;

package/dist/types-ts4.5/extensions/module-helpers.d.ts

@@ -0,0 +1,11 @@
+import type { ADFEntity } from '@atlaskit/adf-utils/types';
+import { ExtensionAPI, ExtensionAutoConvertHandler, ExtensionManifest, ExtensionModule, ExtensionProvider, ExtensionToolbarButton, MenuItem, Parameters } from './types';
+export declare const groupBy: <T>(arr: T[], attr: keyof T, keyRenamer: (key: T[keyof T]) => string) => {
+    [k: string]: T;
+};
+export declare function buildMenuItem<T extends Parameters>(manifest: ExtensionManifest<T>, extensionModule: ExtensionModule<T>): MenuItem;
+export declare const getQuickInsertItemsFromModule: <T extends Parameters>(extensions: ExtensionManifest<T>[], transformFunction: (value: MenuItem, index: number) => T) => T[];
+export declare function getAutoConvertPatternsFromModule<T extends Parameters>(extensions: ExtensionManifest<T>[]): Promise<ExtensionAutoConvertHandler[]>;
+export declare const createAutoConverterRunner: (autoConvertHandlers: ExtensionAutoConvertHandler[]) => ExtensionAutoConvertHandler;
+export declare function getExtensionAutoConvertersFromProvider(extensionProviderPromise: Promise<ExtensionProvider>): Promise<ExtensionAutoConvertHandler>;
+export declare const getContextualToolbarItemsFromModule: (extensions: ExtensionManifest[], node: ADFEntity, api: ExtensionAPI) => ExtensionToolbarButton[];

package/dist/types-ts4.5/extensions/types/extension-handler.d.ts

@@ -0,0 +1,40 @@
+/// <reference types="react" />
+import type { ADFEntity } from '@atlaskit/adf-utils/types';
+import { Parameters } from './extension-parameters';
+export interface ExtensionParams<T extends Parameters> {
+    extensionKey: string;
+    extensionType: string;
+    type?: 'extension' | 'inlineExtension' | 'bodiedExtension';
+    parameters?: T;
+    content?: object | string;
+    localId?: string;
+    fragmentLocalId?: string;
+}
+export type ExtensionHandler<T extends Parameters = Parameters> = (ext: ExtensionParams<T>, doc: object) => JSX.Element | null;
+export type OnSaveCallback<T extends Parameters = Parameters> = (params: T) => void;
+export type TransformBefore<T extends Parameters = Parameters> = (data: T) => any;
+export type TransformAfter<T extends Parameters = Parameters> = (data: any) => Promise<Partial<T>>;
+export type ExtensionAPI<T extends Parameters = Parameters> = {
+    editInContextPanel: (transformBefore: TransformBefore<T>, transformAfter: TransformAfter<T>) => void;
+    _editInLegacyMacroBrowser: () => void;
+    doc: {
+        insertAfter: (localId: string, adf: ADFEntity, options?: {
+            allowSelectionToNewNode?: boolean;
+        }) => void;
+        scrollTo: (localId: string) => void;
+        update: (localId: string, mutationCallback: (currentValue: Pick<ADFEntity, 'content' | 'attrs' | 'marks'>) => Pick<ADFEntity, 'content' | 'attrs' | 'marks'>) => void;
+    };
+};
+export type UpdateExtension<T extends Parameters = Parameters> = (extensionParameters: T, actions?: ExtensionAPI<T>) => Promise<T | void>;
+export interface Extension<T extends Parameters = Parameters> {
+    render: ExtensionHandler<T>;
+    update?: UpdateExtension<T>;
+}
+export interface ExtensionHandlers<T extends Parameters = any> {
+    [key: string]: Extension<T> | ExtensionHandler<T>;
+}
+export type ReferenceEntity = {
+    [prop: string]: ADFEntity | Object;
+};
+export type ParametersGetter<T extends Parameters = Parameters> = TransformBefore<T>;
+export type AsyncParametersGetter<T extends Parameters = Parameters> = TransformAfter<T>;

package/dist/types-ts4.5/extensions/types/extension-manifest-common.d.ts

@@ -0,0 +1,8 @@
+import { ComponentType } from 'react';
+export type ESModule<T> = {
+    __esModule?: boolean;
+    default: T;
+};
+export type MaybeESModule<T> = ESModule<T> | T;
+export type ExtensionIcon = ComponentType<any>;
+export type ExtensionIconModule = Promise<MaybeESModule<ExtensionIcon>>;