@atlaskit/editor-common 76.9.1 → 76.9.2

package/dist/types-ts4.5/element-browser/hooks/use-container-width.d.ts

@@ -0,0 +1,33 @@
+/** @jsx jsx */
+import React from 'react';
+/**
+ *
+ * Problem:
+ * While using WidthObserver, there's no initial width.
+ * That may cause problems, but not limited to, something like a lag between
+ * renders for conditionally rendered components.
+ *
+ * solution:
+ * useContainerWidth() hook
+ * it pre-measures the width of a parent container on initial mount
+ * and gives you back the containerWidth.
+ *
+ *
+ * Example hook usage:
+ *
+ *  const { containerWidth, ContainerWidthMonitor } = useContainerWidth();
+ *
+ *  return (
+ *   <>
+ *    <ContainerWidthMonitor />
+ *    {containerWidth < 600 ? <MobileComponent /> : <DesktopComponent />}
+ *   </>
+ *  );
+ *
+ */
+type useContainerWidthReturnType = {
+    containerWidth: number;
+    ContainerWidthMonitor: React.ElementType;
+};
+export default function useContainerWidth(): useContainerWidthReturnType;
+export {};

package/dist/types-ts4.5/element-browser/hooks/use-focus.d.ts

@@ -0,0 +1,35 @@
+/// <reference types="react" />
+/**
+ * A custom hook that handles focus on a DOM element.
+ * Takes in a boolean value and calls element.focus
+ *
+ * @param {boolean} focus
+ *
+ * Example usage:
+ *******************************************************************************
+ *    const SearchBar = ({ focus }) => {
+ *      const ref = useFocus(focus);
+ *      return <input ref={ref} />
+ *    }
+ *******************************************************************************
+ *    const ItemList = ({ items, focus }) => (
+ *       <ul>
+ *        {items.map((item, index) => (
+ *          <Item key={item.uuid} item={item} focus={focus} />
+ *        ))}
+ *       </ul>
+ *     );
+ *
+ *    const Item = ({ item, focus }) => {
+ *      const ref = useFocus(focus);
+ *      return (
+ *        <li ref={ref}>
+ *          {item.name}
+ *        </li>
+ *      )
+ *    }
+ *******************************************************************************
+ */
+type RefType = null | HTMLInputElement | HTMLDivElement;
+export default function useFocus(focus: boolean): import("react").MutableRefObject<RefType>;
+export {};

package/dist/types-ts4.5/element-browser/hooks/use-select-and-focus-on-arrow-navigation.d.ts

@@ -0,0 +1,72 @@
+import type React from 'react';
+/**
+ * a custom hook that handles keyboard navigation for Arrow keys based on a
+ * given listSize, and a step (for up and down arrows).
+ *
+ * @param {number} listSize
+ * @param {number} upDownStep
+ *
+ * Example usage:
+ *    const list = ['Confluence','Jira','Atlaskit'];
+ *    const {
+ *      selectedItemIndex,
+ *      focusedItemIndex,
+ *      focusOnSearch,
+ *      focusOnViewMore,
+ *      setFocusedItemIndex,
+ *      onKeyDown
+ *    } = useSelectAndFocusOnArrowNavigation(list.length - 1, 1);
+ *
+ *    return (
+ *      <div onKeyDown={onKeyDown}>
+ *        <SearchBar onClick={() => setFocusedItemIndex(undefined)} focus={focusOnSearch} />
+ *        {list.map((item, index) => (
+ *           <ListItem
+ *            title={item}
+ *            style={{ ..., color: selected ? 'selectedStateColor' : defaultColor }}
+ *            onClick={() => {
+ *              setFocusedItemIndex(index);
+ *            }
+ *          />
+ *        )}
+ *      </div>
+ *    );
+ *
+ *    const SearchBar = ({ focus }) => {
+ *      const ref = useRefToFocusOrScroll(focus);
+ *      return <input ref={ref} />
+ *    }
+ *
+ */
+type ReducerState = {
+    focusOnSearch: boolean;
+    focusOnViewMore: boolean;
+    selectedItemIndex?: number;
+    focusedItemIndex?: number;
+    listSize: number;
+    canFocusViewMore?: boolean;
+};
+export declare enum ACTIONS {
+    FOCUS_SEARCH = "focusOnSearch",
+    UPDATE_STATE = "updateState",
+    MOVE = "move"
+}
+export type ReducerAction = {
+    type: ACTIONS;
+    payload: Partial<ReducerState> & {
+        positions?: number;
+        step?: number;
+    };
+};
+export type useSelectAndFocusReturnType = {
+    selectedItemIndex?: number;
+    onKeyDown: (e: React.KeyboardEvent<HTMLDivElement>) => void;
+    focusOnSearch: boolean;
+    focusOnViewMore: boolean;
+    focusedItemIndex?: number;
+    setFocusedItemIndex: (index?: number) => void;
+    setFocusOnSearch: () => void;
+};
+declare function useSelectAndFocusOnArrowNavigation(listSize: number, step: number, canFocusViewMore: boolean): useSelectAndFocusReturnType;
+export declare const ensureSafeIndex: (index: number, listSize: number) => number;
+export default useSelectAndFocusOnArrowNavigation;

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

@@ -0,0 +1,2 @@
+export { default as ElementBrowser } from './components/ElementBrowserLoader';
+export { ELEMENT_ITEM_HEIGHT } from './constants';

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

@@ -0,0 +1,12 @@
+export type Category = {
+    title: string;
+    name: string;
+};
+export declare enum Modes {
+    full = "full",
+    inline = "inline"
+}
+export type SelectedItemProps = {
+    selectedItemIndex?: number;
+    focusedItemIndex?: number;
+};

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 type { PluginKey } from '@atlaskit/editor-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 type { ExtensionProvider } from './types';
+/**
+ * Allow to run methods from the `ExtensionProvider` interface across all providers seamlessly.
+ * This 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 type { 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 type { 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>>;

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

@@ -0,0 +1,45 @@
+import type { ADFEntity } from '@atlaskit/adf-utils/types';
+import { ExtensionAPI } from './extension-handler';
+import { ExtensionIconModule } from './extension-manifest-common';
+export type ToolbarButtonAction = (contextNode: ADFEntity, api: ExtensionAPI) => Promise<void>;
+export type ToolbarButton = ExtensionModuleToolbarButtonLabelOrIcon & {
+    key: string;
+    action: ToolbarButtonAction;
+    label: string;
+    tooltip?: string;
+    icon?: () => ExtensionIconModule;
+    display?: 'icon' | 'label' | 'icon-and-label';
+    disabled?: boolean;
+};
+export type ToolbarItem = ToolbarButton;
+export type ToolbarContext = ExtensionNodeContext | StandardNodeContext;
+export type ContextualToolbar = {
+    context: ToolbarContext;
+    toolbarItems: ToolbarItem[] | ((contextNode: ADFEntity, api: ExtensionAPI) => ToolbarItem[]);
+};
+export type ExtensionModuleToolbarButtonLabelOrIcon = ExtensionModuleToolbarButtonWithIcon | ExtensionModuleToolbarButtonWithLabel;
+export type ExtensionModuleToolbarButtonWithIcon = {
+    icon: () => ExtensionIconModule;
+    display?: 'icon' | 'icon-and-label';
+};
+export type ExtensionModuleToolbarButtonWithLabel = {
+    display?: 'label';
+};
+export type ExtensionNodeContext = {
+    type: 'extension';
+    nodeType: 'extension' | 'inlineExtension' | 'bodiedExtension';
+    extensionKey: string | string[];
+    extensionType?: string;
+};
+export type StandardNodeContext = {
+    type: 'node';
+    nodeType: 'table';
+};
+export type ExtensionToolbarButton = {
+    key: string;
+    label?: string;
+    tooltip?: string;
+    icon?: () => ExtensionIconModule;
+    action: ToolbarButtonAction;
+    disabled?: boolean;
+};

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

@@ -0,0 +1,101 @@
+import { ComponentType } from 'react';
+import type { ADFEntity } from '@atlaskit/adf-utils/types';
+import { ExtensionParams, UpdateExtension } from './extension-handler';
+import { ExtensionIconModule, MaybeESModule } from './extension-manifest-common';
+import { ContextualToolbar } from './extension-manifest-toolbar-item';
+import { Parameters } from './extension-parameters';
+import { FieldDefinition, Option, UserFieldContext } from './field-definitions';
+export type ExtensionType = string;
+export type ExtensionKey = string;
+export type ExtensionModuleKey = string;
+export type ExtensionComponentProps<T extends Parameters = Parameters> = {
+    node: ExtensionParams<T>;
+    [key: string]: any;
+};
+export type ExtensionComponent<T extends Parameters> = ComponentType<ExtensionComponentProps<T>>;
+export type ExtensionComponentModule<T extends Parameters> = Promise<MaybeESModule<ExtensionComponent<T>>>;
+export type Serializer<T extends Parameters = Parameters> = (data: T) => string;
+export type Deserializer<T extends Parameters = Parameters> = (value: string) => T;
+export type ExtensionModuleActionObject<T extends Parameters = Parameters> = {
+    key: ExtensionModuleKey;
+    type: 'node';
+    parameters?: T;
+};
+export type MaybeADFEntity = MaybeESModule<ADFEntity | Array<ADFEntity> | void>;
+export type ExtensionModuleActionHandler = () => Promise<MaybeADFEntity>;
+export type ExtensionModuleAction<T extends Parameters = Parameters> = ExtensionModuleActionObject<T> | ExtensionModuleActionHandler;
+export type ExtensionModule<T extends Parameters = Parameters> = {
+    key: string;
+    title?: string;
+    description?: string;
+    icon?: () => ExtensionIconModule;
+    priority?: number;
+    featured?: boolean;
+    keywords?: string[];
+    categories?: string[];
+    action: ExtensionModuleAction<T>;
+    parameters?: T;
+};
+export type DynamicFieldDefinitions<T> = (parameters: T) => FieldDefinition[];
+export type ExtensionModuleNode<T extends Parameters = Parameters> = {
+    type: 'extension' | 'inlineExtension' | 'bodiedExtension';
+    render: () => ExtensionComponentModule<T>;
+    update?: UpdateExtension<T>;
+    getFieldsDefinition?: (extensionParameters: T) => Promise<FieldDefinition[] | DynamicFieldDefinitions<T>>;
+};
+export type ExtensionModuleNodes<T extends Parameters = Parameters> = {
+    [key: string]: ExtensionModuleNode<T>;
+};
+export type ExtensionAutoConvertHandler = (text: string) => ADFEntity | undefined;
+export type ExtensionModuleAutoConvert = {
+    url?: ExtensionAutoConvertHandler[];
+};
+export type CustomFieldResolver = (searchTerm?: string, defaultValue?: string | string[], parameters?: Parameters) => Promise<Option[]>;
+export type UserFieldContextProvider = () => Promise<UserFieldContext>;
+export type ExtensionModuleFieldTypeCustom = {
+    resolver: CustomFieldResolver;
+};
+export type ExtensionModuleFieldTypeUser = {
+    provider: UserFieldContextProvider;
+};
+export type ExtensionModuleFieldTypeFieldset<T extends Parameters = Parameters> = {
+    serializer?: Serializer<T>;
+    deserializer?: Deserializer<T>;
+};
+export type ExtensionModuleFields<T extends Parameters = Parameters> = {
+    custom?: {
+        [key: string]: ExtensionModuleFieldTypeCustom;
+    };
+    fieldset?: {
+        [key: string]: ExtensionModuleFieldTypeFieldset<T>;
+    };
+    user?: {
+        [key: string]: ExtensionModuleFieldTypeUser;
+    };
+};
+export type ExtensionModules<T extends Parameters = Parameters> = {
+    quickInsert?: ExtensionModule<T>[];
+    nodes?: ExtensionModuleNodes<T>;
+    fields?: ExtensionModuleFields<T>;
+    autoConvert?: ExtensionModuleAutoConvert;
+    contextualToolbars?: ContextualToolbar[];
+};
+export type ExtensionQuickInsertModule = 'quickInsert';
+export type ExtensionModuleType<T extends Parameters = Parameters> = Exclude<keyof ExtensionModules<T>, 'nodes' | 'fields'>;
+export type ExtensionManifest<T extends Parameters = Parameters> = {
+    type: ExtensionType;
+    key: ExtensionKey;
+    title: string;
+    description?: string;
+    summary?: string;
+    categories?: string[];
+    keywords?: string[];
+    documentationUrl?: string;
+    icons: {
+        '48': () => ExtensionIconModule;
+        [dimensions: string]: () => ExtensionIconModule;
+    };
+    modules: ExtensionModules<T>;
+};
+export type Icon = () => ExtensionIconModule;
+export type Module<T extends Parameters> = MaybeESModule<T>;

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

@@ -0,0 +1,5 @@
+export type Parameters = {
+    [key: string]: any;
+    lastIndexOf?: never;
+};
+export type ParametersWithDuplicateFields = Array<Parameters>;

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

@@ -0,0 +1,8 @@
+import { ExtensionAutoConvertHandler, ExtensionKey, ExtensionManifest, ExtensionType } from './extension-manifest';
+import { Parameters } from './extension-parameters';
+export interface ExtensionProvider<T extends Parameters = any> {
+    getExtensions(): Promise<ExtensionManifest<T>[]>;
+    getExtension(type: ExtensionType, key: ExtensionKey): Promise<ExtensionManifest<T> | undefined>;
+    search(keyword: string): Promise<ExtensionManifest<T>[]>;
+    getAutoConverter(): Promise<ExtensionAutoConvertHandler[]>;
+}

package/dist/types-ts4.5/extensions/types/field-definitions.d.ts

@@ -0,0 +1,171 @@
+/// <reference types="react" />
+export type Option = {
+    label: string;
+    value: string;
+    description?: string;
+    /**
+     * If a string is passed, we use a image tag to create an icon.
+     * If a react component is passed, we render as is.
+     * The recommendation is to pass a 16x16 icon if no description is provided, or 24x24 if provided.
+     * We can't enforce the size if a React component is passed so it's on the consumer to make the appropriate choice.
+     */
+    icon?: string | React.ReactNode;
+};
+import { Props as SmartUserPickerProps } from '@atlaskit/smart-user-picker';
+export type UserFieldContext = Pick<SmartUserPickerProps, 'siteId' | 'principalId' | 'fieldId' | 'productKey' | 'containerId' | 'objectId' | 'childObjectId' | 'productAttributes' | 'includeUsers'>;
+interface BaseFieldDefinition {
+    description?: string;
+    label: string;
+    name: string;
+    isRequired?: boolean;
+    allowDuplicates?: boolean;
+    isHidden?: boolean;
+}
+interface BaseEnumField extends BaseFieldDefinition {
+    type: 'enum';
+    items: Option[];
+}
+export interface EnumSingleSelectField extends BaseEnumField {
+    style: 'select';
+    isMultiple?: false;
+    defaultValue?: string;
+    placeholder?: string;
+}
+export interface EnumRadioFieldBase extends BaseEnumField {
+    style: 'radio';
+    isMultiple?: false;
+}
+export interface EnumRadioFieldDefaulted extends EnumRadioFieldBase {
+    isRequired?: false;
+    defaultValue: string;
+}
+export interface EnumRadioFieldRequired extends EnumRadioFieldBase {
+    isRequired: true;
+    defaultValue?: string;
+}
+export type EnumRadioField = EnumRadioFieldDefaulted | EnumRadioFieldRequired;
+export interface EnumMultipleSelectField extends BaseEnumField {
+    style: 'select';
+    isMultiple: true;
+    defaultValue?: string[];
+    placeholder?: string;
+}
+export interface EnumCheckboxField extends BaseEnumField {
+    style: 'checkbox';
+    isMultiple: true;
+    defaultValue?: string[];
+}
+export type EnumSelectField = EnumSingleSelectField | EnumMultipleSelectField;
+export type EnumField = EnumSelectField | EnumRadioField | EnumCheckboxField;
+export interface StringOneLineField extends BaseFieldDefinition {
+    type: 'string';
+    style?: 'oneline';
+    defaultValue?: string;
+    placeholder?: string;
+}
+export interface StringMultilineField extends BaseFieldDefinition {
+    type: 'string';
+    style: 'multiline';
+    defaultValue?: string;
+    placeholder?: string;
+    options?: {
+        minimumRows: number;
+    };
+}
+export type StringField = StringOneLineField | StringMultilineField;
+export interface NumberField extends BaseFieldDefinition {
+    type: 'number';
+    defaultValue?: number;
+    placeholder?: string;
+}
+export interface BooleanField extends BaseFieldDefinition {
+    type: 'boolean';
+    defaultValue?: boolean;
+    style?: 'checkbox' | 'toggle';
+}
+export interface ColorField extends BaseFieldDefinition {
+    type: 'color';
+    defaultValue?: string;
+}
+export interface DateField extends BaseFieldDefinition {
+    type: 'date';
+    defaultValue?: string;
+    placeholder?: string;
+}
+export interface DateRangeField extends BaseFieldDefinition {
+    type: 'date-range';
+    defaultValue?: DateRangeResult;
+    items: Option[];
+}
+export interface DateRangeResult {
+    type: 'date-range';
+    value: 'custom' | any;
+    from?: string;
+    to?: string;
+}
+export type FieldHandlerLink = {
+    type: string;
+};
+interface BaseCustomField extends BaseFieldDefinition {
+    type: 'custom';
+    style?: 'select';
+    options: {
+        isCreatable?: boolean;
+        resolver: FieldHandlerLink;
+    };
+    placeholder?: string;
+}
+export interface CustomSingleField extends BaseCustomField {
+    isMultiple?: false;
+    defaultValue?: string;
+}
+export interface CustomMultipleField extends BaseCustomField {
+    isMultiple: true;
+    defaultValue?: string[];
+}
+export interface UserField extends BaseFieldDefinition {
+    type: 'user';
+    defaultValue?: string | string[] | null | undefined;
+    placeholder?: string;
+    isMultiple?: boolean;
+    options: {
+        provider: FieldHandlerLink;
+    };
+}
+export type CustomField = CustomSingleField | CustomMultipleField;
+export type NativeField = EnumField | StringField | NumberField | BooleanField | ColorField | DateField | DateRangeField;
+export type NestedFieldDefinition = NativeField | CustomField | UserField;
+export interface Fieldset extends BaseFieldDefinition {
+    type: 'fieldset';
+    fields: NestedFieldDefinition[];
+    options: {
+        isDynamic?: boolean;
+        transformer: FieldHandlerLink;
+        showTitle?: boolean;
+    };
+}
+export type FieldDefinition = NestedFieldDefinition | Fieldset | GroupingField;
+export declare const isFieldset: (field: FieldDefinition) => field is Fieldset;
+export declare const isTabGroup: (field: FieldDefinition) => field is TabGroupField;
+export declare const isTabField: (field: any) => field is TabField;
+export declare const isExpand: (field: FieldDefinition) => field is ExpandField;
+export declare const isDateRange: (value: any) => value is DateRangeResult;
+export interface GroupedField extends BaseFieldDefinition {
+    fields: NestedFieldDefinition[];
+    hasGroupedValues?: boolean;
+}
+export interface ExpandField extends GroupedField {
+    type: 'expand';
+    isExpanded?: boolean;
+}
+export interface TabGroupField extends Omit<GroupedField, 'fields'> {
+    type: 'tab-group';
+    defaultTab?: string;
+    fields: TabField[];
+}
+export interface TabField extends Omit<GroupedField, 'fields'> {
+    type: 'tab';
+    fields: (NestedFieldDefinition | ExpandField)[];
+}
+export type GroupingField = ExpandField | TabGroupField;
+export {};