@atlaskit/editor-common 107.28.2 → 107.29.0

package/dist/types/link/LinkSearch/types.d.ts

@@ -4,44 +4,44 @@ import { type INPUT_METHOD } from '../../analytics';
 export type RecentSearchInputTypes = INPUT_METHOD.TYPEAHEAD | INPUT_METHOD.MANUAL;
 export interface ChildProps {
     activityProvider: ActivityProvider | null;
+    clearValue(): void;
+    currentInputMethod?: RecentSearchInputTypes;
     inputProps: {
         onChange(input: string): void;
         onKeyDown(event: KeyboardEvent<any>): void;
         onSubmit(): void;
         value: string;
     };
-    currentInputMethod?: RecentSearchInputTypes;
-    clearValue(): void;
     renderRecentList(): React.ReactNode;
 }
 export interface RecentSearchSubmitOptions {
+    inputMethod: RecentSearchInputTypes;
     text: string;
     url: string;
-    inputMethod: RecentSearchInputTypes;
 }
 export interface RecentSearchProps {
     defaultUrl?: string;
-    onSubmit(options: RecentSearchSubmitOptions): void;
+    limit?: number;
     onBlur(options: RecentSearchSubmitOptions): void;
+    onSubmit(options: RecentSearchSubmitOptions): void;
     render(state: ChildProps): React.ReactNode;
-    limit?: number;
 }
 export interface RecentSearchState {
+    isLoading: boolean;
     items: Array<ActivityItem>;
     selectedIndex: number;
-    isLoading: boolean;
     url: string;
 }
 export type LinkSearchListItemData = {
-    objectId: string;
-    name: string;
     container: string;
-    url: string;
-    iconUrl?: string | never;
     icon?: React.ReactChild | never;
-    lastViewedDate?: Date;
+    iconUrl?: string | never;
     lastUpdatedDate?: Date;
+    lastViewedDate?: Date;
+    name: string;
+    objectId: string;
     prefetch?: boolean;
+    url: string;
 } & ({
     iconUrl: string;
 } | {

package/dist/types/link/types.d.ts

@@ -17,30 +17,30 @@ export declare enum InsertStatus {
     EDIT_INSERTED_TOOLBAR = "EDIT_INSERTED"
 }
 export type InsertState = {
-    type: InsertStatus.INSERT_LINK_TOOLBAR;
     from: number;
     to: number;
+    type: InsertStatus.INSERT_LINK_TOOLBAR;
 };
 export type EditInsertedState = {
-    type: InsertStatus.EDIT_INSERTED_TOOLBAR;
     node: Node;
     pos: number;
+    type: InsertStatus.EDIT_INSERTED_TOOLBAR;
 };
 export type EditState = {
-    type: InsertStatus.EDIT_LINK_TOOLBAR;
     node: Node;
     pos: number;
+    type: InsertStatus.EDIT_LINK_TOOLBAR;
 };
 export type LinkToolbarState = EditState | EditInsertedState | InsertState | undefined;
 export interface HyperlinkState {
-    activeText?: string;
     activeLinkMark?: LinkToolbarState;
-    timesViewed: number;
+    activeText?: string;
     canInsertLink: boolean;
-    searchSessionId?: string;
-    inputMethod?: INPUT_METHOD;
-    editorAppearance?: EditorAppearance;
     configureButtonTargetPos?: number;
-    decorations?: DecorationSet;
     configureDropdownOpen?: boolean;
+    decorations?: DecorationSet;
+    editorAppearance?: EditorAppearance;
+    inputMethod?: INPUT_METHOD;
+    searchSessionId?: string;
+    timesViewed: number;
 }

package/dist/types/lists/indentation.d.ts

@@ -1,5 +1,5 @@
 import type { Transaction } from '@atlaskit/editor-prosemirror/state';
 export declare const hasValidListIndentationLevel: ({ tr, maxIndentation, }: {
-    tr: Transaction;
     maxIndentation: number;
+    tr: Transaction;
 }) => boolean;

package/dist/types/lists/node.d.ts

@@ -6,13 +6,13 @@ export declare enum JoinDirection {
     RIGHT = -1
 }
 type JoinSiblingListsProps = {
-    tr: Transaction;
     direction?: JoinDirection;
     forceListType?: NodeType;
+    tr: Transaction;
 };
 type ListsJoined = {
-    orderedList: number;
     bulletList: number;
+    orderedList: number;
 };
 export declare const joinSiblingLists: ({ tr, direction, forceListType, }: JoinSiblingListsProps) => ListsJoined;
 export declare const processNestedTaskListsInSameLevel: (tr: Transaction) => void;

package/dist/types/lists/replace-content.d.ts

@@ -2,8 +2,8 @@ import type { ResolvedPos } from '@atlaskit/editor-prosemirror/model';
 import type { Transaction } from '@atlaskit/editor-prosemirror/state';
 import type { Step } from '@atlaskit/editor-prosemirror/transform';
 type Params = {
-    insertPosition: number;
     $target: ResolvedPos;
+    insertPosition: number;
 };
 export declare const moveTargetIntoList: ({ insertPosition, $target }: Params) => Step;
 export declare const wrapTaskListIntoListAbove: (tr: Transaction, taskListStart: number, previousListStart: number) => void;

package/dist/types/lists/selection.d.ts

@@ -6,8 +6,8 @@ export declare const getListItemAttributes: ($pos: ResolvedPos) => {
     itemIndex: number;
 };
 type NormalizeListItemsSelection = (props: {
-    selection: Selection;
     doc: PMNode;
+    selection: Selection;
 }) => Selection;
 export declare const normalizeListItemsSelection: NormalizeListItemsSelection;
 export {};

package/dist/types/media-inline/inline-image-card.d.ts

@@ -2,14 +2,14 @@ import type { FileIdentifier } from '@atlaskit/media-client';
 import type { SSR } from '@atlaskit/media-common';
 import type { Dimensions } from './types';
 export declare const InlineImageCard: ({ dimensions, identifier, renderError, alt, isLazy, ssr, crop, stretch, }: {
+    alt?: string;
+    crop?: boolean;
+    dimensions?: Dimensions;
     identifier: FileIdentifier;
+    isLazy?: boolean;
     renderError: (props: {
         error: Error;
     }) => JSX.Element | null;
-    dimensions?: Dimensions;
-    isLazy?: boolean;
-    alt?: string;
     ssr?: SSR;
-    crop?: boolean;
     stretch?: boolean;
 }) => JSX.Element | null;

package/dist/types/media-inline/inline-image-wrapper.d.ts

@@ -5,14 +5,14 @@
 import type { ReactElement } from 'react';
 import { jsx } from '@emotion/react';
 type Props = {
-    children: ReactElement;
-    isSelected?: boolean;
     aspectRatio?: number | string;
-    borderSize?: number;
     borderColor?: string;
+    borderSize?: number;
+    children: ReactElement;
     htmlAttrs?: {
         [key: string]: string | number | undefined;
     };
+    isSelected?: boolean;
     onClick?: React.EventHandler<React.MouseEvent | React.KeyboardEvent>;
 };
 export declare const InlineImageWrapper: ({ children, isSelected, aspectRatio, borderSize, borderColor, htmlAttrs, onClick, }: React.PropsWithChildren<Props>) => jsx.JSX.Element;

package/dist/types/media-inline/media-inline-image-card.d.ts

@@ -3,18 +3,18 @@ import type { WrappedComponentProps } from 'react-intl-next';
 import type { FileIdentifier, MediaClient } from '@atlaskit/media-client';
 import type { MediaInlineAttrs, MediaSSR } from './types';
 export interface MediaInlineImageCardProps {
-    identifier: FileIdentifier;
-    mediaClient?: MediaClient;
-    isSelected?: boolean;
-    isLazy?: boolean;
-    serializeDataAttrs?: boolean;
     border?: {
-        borderSize?: number;
         borderColor?: string;
+        borderSize?: number;
     };
-    ssr?: MediaSSR;
-    shouldOpenMediaViewer?: boolean;
+    identifier: FileIdentifier;
+    isLazy?: boolean;
+    isSelected?: boolean;
     isViewOnly?: boolean;
+    mediaClient?: MediaClient;
+    serializeDataAttrs?: boolean;
+    shouldOpenMediaViewer?: boolean;
+    ssr?: MediaSSR;
 }
 export declare const MediaInlineImageCardInternal: ({ mediaClient, identifier, isSelected, intl, alt, isLazy, width, height, border, ssr, serializeDataAttrs, shouldOpenMediaViewer, isViewOnly, }: MediaInlineImageCardProps & WrappedComponentProps & MediaInlineAttrs) => jsx.JSX.Element;
 export declare const MediaInlineImageCard: React.ComponentType<React.PropsWithChildren<MediaInlineImageCardProps & MediaInlineAttrs>>;

package/dist/types/media-inline/types.d.ts

@@ -1,16 +1,16 @@
 import type { SSR } from '@atlaskit/media-common';
 import type { MediaClientConfig } from '@atlaskit/media-core';
 export type MediaInlineAttrs = {
-    type?: string;
     alt?: string;
-    width?: number;
     height?: number;
+    type?: string;
+    width?: number;
 };
 export type MediaSSR = {
-    mode: SSR;
     config: MediaClientConfig;
+    mode: SSR;
 };
 export type Dimensions = {
-    width?: number;
     height?: number;
+    width?: number;
 };

package/dist/types/media-inline/views/error-view.d.ts

@@ -4,12 +4,12 @@
  */
 import { jsx } from '@emotion/react';
 type Props = {
-    message: string;
+    /** Container height */
+    height?: number;
     /** Error icon. Default to document icon. */
     icon?: React.ReactNode;
+    message: string;
     testId?: string;
-    /** Container height */
-    height?: number;
 };
 export declare const InlineImageCardErrorView: ({ testId, message, icon, height, }: Props) => jsx.JSX.Element;
 export {};

package/dist/types/media-inline/views/loading-view.d.ts

@@ -4,10 +4,10 @@
  */
 import { jsx } from '@emotion/react';
 type Props = {
-    title?: string;
-    testId?: string;
     /** Container height */
     height?: number;
+    testId?: string;
+    title?: string;
 };
 export declare const InlineImageCardLoadingView: ({ testId, height, }: Props) => jsx.JSX.Element;
 export {};

package/dist/types/media-single/CommentBadge.d.ts

@@ -1,16 +1,16 @@
 import type { IntlShape } from 'react-intl-next';
 export declare const getBadgeSize: (width?: number, height?: number) => "medium" | "small";
 export type CommentBadgeProps = {
-    intl: IntlShape;
-    width?: number;
+    badgeOffsetRight?: string;
     height?: number;
-    status?: 'default' | 'entered' | 'active';
+    intl: IntlShape;
+    isDrafting?: boolean;
+    isEditor?: boolean;
     mediaSingleElement?: HTMLElement | null;
     onClick: (e: React.MouseEvent) => void;
     onMouseEnter?: (e: React.MouseEvent) => void;
     onMouseLeave?: (e: React.MouseEvent) => void;
-    isEditor?: boolean;
-    isDrafting?: boolean;
-    badgeOffsetRight?: string;
+    status?: 'default' | 'entered' | 'active';
+    width?: number;
 };
 export declare const CommentBadge: import("react").ForwardRefExoticComponent<CommentBadgeProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist/types/media-single/CommentBadgeNext.d.ts

@@ -1,10 +1,10 @@
 import React from 'react';
 type CommentBadgeProps = {
-    status?: 'default' | 'entered' | 'active';
     mediaSingleElement?: HTMLElement | null;
     onClick: (e: React.MouseEvent) => void;
     onMouseEnter?: (e: React.MouseEvent) => void;
     onMouseLeave?: (e: React.MouseEvent) => void;
+    status?: 'default' | 'entered' | 'active';
 };
 export declare const CommentBadgeNext: ({ status, onClick, onMouseEnter, onMouseLeave, }: CommentBadgeProps) => React.JSX.Element;
 export {};

package/dist/types/media-single/MediaBadges.d.ts

@@ -1,13 +1,13 @@
 import React, { type ReactNode } from 'react';
 type ExternalImageBadgeProps = {
+    children: ReactNode | ((props: {
+        visible: boolean;
+    }) => ReactNode);
+    extendedResizeOffset?: boolean;
     mediaElement?: HTMLElement | null;
     mediaHeight?: number;
     mediaWidth?: number;
-    extendedResizeOffset?: boolean;
     useMinimumZIndex?: boolean;
-    children: ReactNode | ((props: {
-        visible: boolean;
-    }) => ReactNode);
 };
 export declare const MediaBadges: ({ children, mediaElement, mediaWidth, mediaHeight, extendedResizeOffset, useMinimumZIndex, }: ExternalImageBadgeProps) => React.JSX.Element | null;
 export {};

package/dist/types/media-single/utils.d.ts

@@ -17,13 +17,13 @@ import type { EditorAppearance } from '../types';
  */
 export declare function getMediaSinglePixelWidth(width: number, editorWidth: number, widthType?: string, gutterOffset?: number): number;
 export interface calcMediaSinglePixelWidthProps {
-    width?: number;
-    widthType?: 'percentage' | 'pixel';
-    origWidth: number;
-    layout: RichMediaLayout;
-    contentWidth?: number;
     containerWidth: number;
+    contentWidth?: number;
     gutterOffset: number;
+    layout: RichMediaLayout;
+    origWidth: number;
+    width?: number;
+    widthType?: 'percentage' | 'pixel';
 }
 /**
  * Convert width attribute to pixel value for legacy (resized or not resisized) and new media single node for new experience

package/dist/types/node-visibility/node-visibility-manager.d.ts

@@ -3,6 +3,11 @@ type NodeObservationConfig = {
     onFirstVisible: () => void;
 };
 export type NodeVisibilityManager = {
+    /**
+     * Kills the IntersectionObserver and all callbacks
+     * @returns
+     */
+    disconnect: () => void;
     /**
      * Establishes IntersectionObserver for the editor to monitor all node viewport visibility
      * @param editorDivElement
@@ -13,11 +18,6 @@ export type NodeVisibilityManager = {
      * observes specific node element with callbacks for triggering when the node is visible or hidden
      */
     observe: (observeConfig: NodeObservationConfig) => () => void;
-    /**
-     * Kills the IntersectionObserver and all callbacks
-     * @returns
-     */
-    disconnect: () => void;
 };
 type NodeVisibilityManagerFn = (editorElement: HTMLElement) => NodeVisibilityManager;
 /**

package/dist/types/portal/PortalManager.d.ts

@@ -1,8 +1,8 @@
 type PortalsBucketUpdater = React.Dispatch<React.SetStateAction<Record<string | number, React.ReactPortal>>>;
 type PortalRendererUpdater = React.Dispatch<React.SetStateAction<Array<PortalBucketType>>>;
 type PortalBucketType = {
-    portals: Record<string | number, React.ReactPortal>;
     capacity: number;
+    portals: Record<string | number, React.ReactPortal>;
     updater: PortalsBucketUpdater | null;
 };
 /**

package/dist/types/portal/common.d.ts

@@ -4,9 +4,9 @@ type RenderFn = (children: () => React.ReactChild | JSX.Element | null, containe
 type RemoveFn = (key: string) => void;
 type DestoryFn = () => void;
 export interface PortalProviderAPI {
-    render: RenderFn;
-    remove: RemoveFn;
     destroy: DestoryFn;
+    remove: RemoveFn;
+    render: RenderFn;
 }
 export type PortalRendererComponent = () => JSX.Element;
 export type UsePortalProviderReturnType = [PortalProviderAPI, PortalRendererComponent];

package/dist/types/preset/builder.d.ts

@@ -52,8 +52,8 @@ type PluginWithConfiguration<Plugin> = undefined extends ExtractPluginConfigurat
  * ```
  */
 type ExtractPluginConfiguration<Plugin> = Plugin extends NextEditorPlugin<any, any> ? Plugin extends (props: {
-    config: any;
     api: any;
+    config: any;
 }) => DefaultEditorPlugin<any, infer Metadata> ? ExtractPluginConfigurationFromMetadata<Metadata> : never : never;
 /**
  * 🧱 Internal Type: Editor FE Platform

package/dist/types/preset/plugin-injection-api.d.ts

@@ -7,8 +7,8 @@ type SharedStateAPIProps = {
     getEditorState: () => EditorState | undefined;
 };
 interface PluginInjectionAPIProps extends SharedStateAPIProps {
-    getEditorView: () => EditorView | undefined;
     fireAnalyticsEvent?: FireAnalyticsCallback;
+    getEditorView: () => EditorView | undefined;
 }
 export type EditorStateDiff = {
     readonly newEditorState: EditorState;
@@ -34,12 +34,12 @@ interface PluginInjectionAPIDefinition {
     api: () => {
         [key: string]: BasePluginDependenciesAPI<any>;
     };
-    onEditorViewUpdated: (props: EditorStateDelta) => void;
     onEditorPluginInitialized: (plugin: NextEditorPluginInitializedType) => void;
+    onEditorViewUpdated: (props: EditorStateDelta) => void;
 }
 type GenericAPIWithCore = {
-    core: PluginDependenciesAPI<CorePlugin>;
     [key: string]: BasePluginDependenciesAPI<any>;
+    core: PluginDependenciesAPI<CorePlugin>;
 };
 export declare class EditorPluginInjectionAPI implements PluginInjectionAPIDefinition {
     private sharedStateAPI;

package/dist/types/provider-factory/card-provider.d.ts

@@ -1,6 +1,6 @@
 import type { CardAdf, DatasourceAdf } from '@atlaskit/linking-common';
 export type CardAppearance = 'inline' | 'block' | 'embed';
 export interface CardProvider {
-    resolve(url: string, appearance: CardAppearance, shouldForceAppearance?: boolean, isEmbedFriendlyLocation?: boolean): Promise<CardAdf | DatasourceAdf>;
     findPattern(url: string): Promise<boolean>;
+    resolve(url: string, appearance: CardAppearance, shouldForceAppearance?: boolean, isEmbedFriendlyLocation?: boolean): Promise<CardAdf | DatasourceAdf>;
 }

package/dist/types/provider-factory/context-identifier-provider.d.ts

@@ -1,6 +1,6 @@
 export interface ContextIdentifierProvider {
+    childObjectId?: string;
     containerId: string;
     objectId: string;
-    childObjectId?: string;
     product?: string;
 }

package/dist/types/provider-factory/image-upload-provider.d.ts

@@ -1,7 +1,7 @@
 import type { ImageUploadPluginReferenceEvent } from '../types';
 export type InsertedImageProperties = {
-    src?: string;
     alt?: string;
+    src?: string;
     title?: string;
 };
 export type ImageUploadProvider = (e: ImageUploadPluginReferenceEvent | undefined, insertImageFn: (props: InsertedImageProperties) => void) => void;

package/dist/types/provider-factory/macro-provider.d.ts

@@ -2,24 +2,24 @@ import type { ExtensionLayout } from '@atlaskit/adf-schema';
 import type { Node as PmNode } from '@atlaskit/editor-prosemirror/model';
 export type ExtensionType = 'extension' | 'bodiedExtension' | 'inlineExtension' | 'multiBodiedExtension';
 export interface MacroAttributes {
-    type: ExtensionType;
     attrs: {
         extensionKey: string;
         extensionType: string;
+        layout?: ExtensionLayout;
         parameters?: {
-            macroParams?: object;
             macroMetadata?: object;
+            macroParams?: object;
         };
-        layout?: ExtensionLayout;
         text?: string;
     };
     content?: any;
+    type: ExtensionType;
 }
 export interface MacroProvider {
+    autoConvert(link: string): MacroAttributes | null;
     config: Object;
     /**
      * If "macro" param is passed in, it will open macro browser for editing the macro
      */
     openMacroBrowser(macroNode?: PmNode): Promise<MacroAttributes>;
-    autoConvert(link: string): MacroAttributes | null;
 }

package/dist/types/provider-factory/media-provider.d.ts

@@ -1,20 +1,20 @@
 import type { MediaClientConfig } from '@atlaskit/media-core/auth';
 import type { UploadParams } from '@atlaskit/media-picker/types';
 export type MediaProvider = {
-    uploadParams?: UploadParams;
     /**
      * (optional) Used for creating new uploads and finalizing files.
      * NOTE: We currently don't accept MediaClientConfig, because we need config properties
      *       to initialize
      */
     uploadMediaClientConfig?: MediaClientConfig;
-    /**
-     * Used for displaying Media Cards and downloading files.
-     */
-    viewMediaClientConfig: MediaClientConfig;
+    uploadParams?: UploadParams;
     /**
      * Used for displaying and downloading files OR uploading files. The operation will be determined by Media on each request.
      * This will be a replacement for viewMediaClientConfig and uploadMediaClientConfig together
      */
     viewAndUploadMediaClientConfig?: MediaClientConfig;
+    /**
+     * Used for displaying Media Cards and downloading files.
+     */
+    viewMediaClientConfig: MediaClientConfig;
 };

package/dist/types/provider-factory/profile-card-provider.d.ts

@@ -1,6 +1,6 @@
 import { type ProfileCardAction, type ProfileClient } from '@atlaskit/profilecard';
 export interface ProfilecardProvider {
     cloudId: string;
-    resourceClient: ProfileClient;
     getActions: (id: string, text: string, accessLevel?: string) => ProfileCardAction[];
+    resourceClient: ProfileClient;
 }

package/dist/types/provider-factory/quick-insert-provider.d.ts

@@ -7,16 +7,6 @@ export type QuickInsertActionInsert = (node?: Node | Record<string, any> | strin
 }) => Transaction;
 export type QuickInsertItemId = 'hyperlink' | 'table' | 'helpdialog' | 'date' | 'media' | 'media-insert' | 'blockquote' | 'heading1' | 'heading2' | 'heading3' | 'heading4' | 'heading5' | 'heading6' | 'codeblock' | 'unorderedList' | 'feedbackdialog' | 'orderedList' | 'rule' | 'status' | 'mention' | 'emoji' | 'action' | 'decision' | 'infopanel' | 'notepanel' | 'successpanel' | 'warningpanel' | 'errorpanel' | 'custompanel' | 'layout' | 'expand' | 'placeholderText' | 'datasource' | 'loom' | 'onecolumnlayout' | 'twocolumnslayout' | 'threecolumnslayout' | 'fourcolumnslayout' | 'fivecolumnslayout';
 export type QuickInsertItem = TypeAheadItem & {
-    /** other names used to find the item */
-    keywords?: Array<string>;
-    /** categories where to find the item */
-    categories?: Array<string>;
-    /** optional sorting priority */
-    priority?: number;
-    /** optional identifier */
-    id?: QuickInsertItemId;
-    /** indicates if the item will be highlighted where appropriate (plus menu for now) */
-    featured?: boolean;
     /**
      * What to do on insert
      *
@@ -25,6 +15,16 @@ export type QuickInsertItem = TypeAheadItem & {
      * @see packages/editor/editor-core/src/plugins/insert-block/ui/ToolbarInsertBlock/index.tsx for details
      */
     action: (insert: QuickInsertActionInsert, state: EditorState, source?: INPUT_METHOD.TOOLBAR | INPUT_METHOD.QUICK_INSERT) => Transaction | false;
+    /** categories where to find the item */
+    categories?: Array<string>;
+    /** indicates if the item will be highlighted where appropriate (plus menu for now) */
+    featured?: boolean;
+    /** optional identifier */
+    id?: QuickInsertItemId;
+    /** other names used to find the item */
+    keywords?: Array<string>;
+    /** optional sorting priority */
+    priority?: number;
 };
 export type QuickInsertProvider = {
     getItems: () => Promise<Array<QuickInsertItem>>;

package/dist/types/provider-factory/search-provider.d.ts

@@ -1,10 +1,10 @@
 export interface QuickSearchResult {
-    objectId: string;
-    title: string;
-    url: string;
     container: string;
     contentType: LinkContentType;
+    objectId: string;
+    title: string;
     updatedTimestamp?: string;
+    url: string;
 }
 export type LinkContentType = 'jira.issue' | 'jira.issue.bug' | 'jira.issue.story' | 'jira.issue.task' | 'confluence.page' | 'confluence.blogpost' | 'default';
 export interface SearchProvider {

package/dist/types/provider-factory/types.d.ts

@@ -14,23 +14,23 @@ import type { ProfilecardProvider } from './profile-card-provider';
 import type { QuickInsertProvider } from './quick-insert-provider';
 import type { SearchProvider } from './search-provider';
 export interface Providers {
-    mediaProvider?: Promise<MediaProvider>;
-    emojiProvider?: Promise<EmojiProvider>;
-    mentionProvider?: Promise<MentionProvider>;
-    extensionProvider?: Promise<ExtensionProvider>;
+    activityProvider?: Promise<ActivityProvider>;
     autoformattingProvider?: Promise<AutoformattingProvider>;
-    taskDecisionProvider?: Promise<TaskDecisionProvider>;
+    cardProvider?: Promise<CardProvider>;
+    collabEditProvider?: Promise<CollabEditProvider>;
     contextIdentifierProvider?: Promise<ContextIdentifierProvider>;
+    emojiProvider?: Promise<EmojiProvider>;
+    extensionProvider?: Promise<ExtensionProvider>;
     imageUploadProvider?: Promise<ImageUploadProvider>;
-    collabEditProvider?: Promise<CollabEditProvider>;
     macroProvider?: Promise<MacroProvider>;
-    cardProvider?: Promise<CardProvider>;
-    quickInsertProvider?: Promise<QuickInsertProvider>;
-    profilecardProvider?: Promise<ProfilecardProvider>;
-    searchProvider?: Promise<SearchProvider>;
-    activityProvider?: Promise<ActivityProvider>;
+    mediaProvider?: Promise<MediaProvider>;
+    mentionProvider?: Promise<MentionProvider>;
     presenceProvider?: Promise<any>;
+    profilecardProvider?: Promise<ProfilecardProvider>;
+    quickInsertProvider?: Promise<QuickInsertProvider>;
     reactionsStore?: Promise<any>;
+    searchProvider?: Promise<SearchProvider>;
+    taskDecisionProvider?: Promise<TaskDecisionProvider>;
 }
 export type ProviderName = keyof Providers;
 export type ProviderType<T> = T extends keyof Providers ? Providers[T] : Promise<any>;

package/dist/types/provider-helpers/promise-helpers.d.ts

@@ -7,8 +7,8 @@ type FulfiledResult<T> = {
     value: T;
 };
 type RejectedResult = {
-    status: ResultStatus.FAILED;
     reason: any;
+    status: ResultStatus.FAILED;
 };
 /**
  * Will wait for all promises to resolve or reject, wrapping their real results in

package/dist/types/quick-insert/use-icon-themed.d.ts

@@ -3,7 +3,7 @@
  */
 export declare const useIconThemed: () => {
     iconThemed: (colors: {
-        light: string;
         dark: string;
+        light: string;
     }) => string;
 };