@atlaskit/editor-common 74.0.0 → 74.1.0

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 {};

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

@@ -0,0 +1,8 @@
+export type { ExtensionParams, ExtensionHandler, UpdateExtension, Extension, ExtensionHandlers, ExtensionAPI, OnSaveCallback, TransformBefore, TransformAfter, ReferenceEntity, ParametersGetter, AsyncParametersGetter, } from './extension-handler';
+export type { ExtensionProvider } from './extension-provider';
+export type { ExtensionAutoConvertHandler, ExtensionComponentProps, ExtensionKey, ExtensionManifest, ExtensionModule, ExtensionModuleAction, ExtensionModuleActionHandler, ExtensionModuleActionObject, ExtensionModuleAutoConvert, ExtensionModuleNode, ExtensionModuleNodes, ExtensionModuleType, ExtensionModules, ExtensionQuickInsertModule, ExtensionType, CustomFieldResolver, UserFieldContextProvider, Icon, MaybeADFEntity, Deserializer, Serializer, DynamicFieldDefinitions, } from './extension-manifest';
+export type { ContextualToolbar, ToolbarItem, ExtensionToolbarButton, } from './extension-manifest-toolbar-item';
+export type { Parameters, ParametersWithDuplicateFields, } from './extension-parameters';
+export type { MenuItem, MenuItemMap } from './utils';
+export { isFieldset, isTabGroup, isTabField, isExpand, isDateRange, } from './field-definitions';
+export type { BooleanField, CustomField, ColorField, DateField, DateRangeField, DateRangeResult, EnumField, EnumCheckboxField, EnumRadioField, EnumSelectField, ExpandField, FieldDefinition, Fieldset, GroupingField, NativeField, NestedFieldDefinition, NumberField, Option, StringField, StringOneLineField, StringMultilineField, TabGroupField, TabField, UserField, UserFieldContext, FieldHandlerLink, } from './field-definitions';

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

@@ -0,0 +1,18 @@
+import type { ADFEntity } from '@atlaskit/adf-utils/types';
+import { ExtensionModuleActionHandler, ExtensionType, Icon } from './extension-manifest';
+export type MenuItem = {
+    key: string;
+    extensionType: ExtensionType;
+    title: string;
+    description?: string;
+    summary?: string;
+    documentationUrl?: string;
+    featured: boolean;
+    keywords: string[];
+    categories: string[];
+    icon: Icon;
+    node: ADFEntity | ExtensionModuleActionHandler;
+};
+export type MenuItemMap = {
+    [key: string]: MenuItem;
+};

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

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

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

@@ -0,0 +1,3 @@
+export { default as usePreviousState } from './usePreviousState';
+export { default as useConstructor } from './useConstructor';
+export { useSharedPluginState } from './useSharedPluginState';

package/dist/types-ts4.5/hooks/useConstructor.d.ts

@@ -0,0 +1,9 @@
+/**
+ *
+ * Hook to run code once in a functional component.
+ * Emulates the behaviour of a `constructor` in a class component
+ * Place this at the top of your functional component so that it is run first.
+ *
+ * @param callback Callback function to run once
+ */
+export default function useConstructor(callback: () => void): void;

package/dist/types-ts4.5/hooks/usePreviousState.d.ts

@@ -0,0 +1,11 @@
+/**
+ *
+ * Can be used to get the previous state of a prop.
+ * This can be helpful when converting class components to functional
+ * where we don't have the `prevProps`.
+ *
+ * @param value New state of the
+ * @param initialValue Optional parameter for the inital state of the component
+ * @returns
+ */
+export default function usePreviousState<T>(value: T, initialValue?: T): T | undefined;

package/dist/types-ts4.5/hooks/useSharedPluginState.d.ts

@@ -0,0 +1,39 @@
+import type { ExtractPluginSharedState, NextEditorPluginMetadata, PluginDependenciesAPI, PluginInjectionAPI } from '../types/next-editor-plugin';
+type NamedPluginStatesFromInjectionAPI<API extends PluginInjectionAPI<any, any> | undefined, PluginList extends string[]> = Readonly<{
+    [K in PluginList[number] as `${K}State`]: API extends PluginInjectionAPI<any, any> ? API['dependencies'][K] extends PluginDependenciesAPI<infer Plugin> | undefined ? ExtractPluginSharedState<Plugin> | undefined : never : never;
+}>;
+type ExtractPluginNames<Name extends string, Metadata extends NextEditorPluginMetadata> = keyof PluginInjectionAPI<Name, Metadata>['dependencies'];
+/**
+ *
+ * Used to return the current plugin state of
+ * input dependencies
+ *
+ * Example in plugin:
+ *
+ * ```typescript
+ * function ExampleContent({ api }: Props) {
+ *   const { dogState, exampleState } = useSharedPluginState(
+ *     api,
+ *     ['dog', 'example']
+ *   )
+ *   return <p>{ dogState.title } { exampleState.description }</p>
+ * }
+ *
+ * const examplePlugin: NextEditorPlugin<'example', { dependencies: [typeof pluginDog] }> = (_, api) => {
+ *   return {
+ *     name: 'example',
+ *     contentComponent: () =>
+ *       <ExampleContent
+ *         api={api}
+ *         />
+ *   }
+ * }
+ * ```
+ *
+ * @param injectionApi Plugin injection API from `NextEditorPlugin`
+ * @param plugins Plugin names to get the shared plugin state for
+ * @returns A corresponding object, the keys are names of the plugin with `State` appended,
+ * the values are the shared state exposed by that plugin.
+ */
+export declare function useSharedPluginState<Name extends string, Metadata extends NextEditorPluginMetadata, PluginNames extends ExtractPluginNames<Name, Metadata>[]>(injectionApi: PluginInjectionAPI<Name, Metadata> | undefined, plugins: PluginNames): NamedPluginStatesFromInjectionAPI<typeof injectionApi, PluginNames>;
+export {};

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

@@ -0,0 +1,133 @@
+/**
+ * NOTE:
+ *
+ * This file is automatically generated by Traduki 2.0.
+ * DO NOT CHANGE IT BY HAND or your changes will be lost.
+ */
+declare const _default: {
+    'fabric.editor.action': string;
+    'fabric.editor.action.description': string;
+    'fabric.editor.addMediaFiles': string;
+    'fabric.editor.alignImageCenter': string;
+    'fabric.editor.alignImageLeft': string;
+    'fabric.editor.alignImageRight': string;
+    'fabric.editor.blockquote': string;
+    'fabric.editor.cancelButton': string;
+    'fabric.editor.captionPlaceholder': string;
+    'fabric.editor.codeBidiWarningLabel': string;
+    'fabric.editor.codeBlockCopyButton.copiedToClipboard': string;
+    'fabric.editor.codeBlockCopyButton.copyToClipboard': string;
+    'fabric.editor.codeBlockWrapButton.unwrapCodeBlock': string;
+    'fabric.editor.codeBlockWrapButton.wrapCodeBlock': string;
+    'fabric.editor.collapseNode': string;
+    'fabric.editor.columns': string;
+    'fabric.editor.columns.description': string;
+    'fabric.editor.copiedToClipboard': string;
+    'fabric.editor.copyToClipboard': string;
+    'fabric.editor.date': string;
+    'fabric.editor.date.description': string;
+    'fabric.editor.decision': string;
+    'fabric.editor.decision.description': string;
+    'fabric.editor.editMode.inviteToEditButton.title': string;
+    'fabric.editor.emoji': string;
+    'fabric.editor.emoji.description': string;
+    'fabric.editor.expand': string;
+    'fabric.editor.expand.description': string;
+    'fabric.editor.expandDefaultTitle': string;
+    'fabric.editor.expandNode': string;
+    'fabric.editor.expandPlaceholder': string;
+    'fabric.editor.feedbackDialog': string;
+    'fabric.editor.feedbackDialog.description': string;
+    'fabric.editor.help': string;
+    'fabric.editor.help.description': string;
+    'fabric.editor.horizontalRule': string;
+    'fabric.editor.horizontalRule.description': string;
+    'fabric.editor.image': string;
+    'fabric.editor.insertMenu': string;
+    'fabric.editor.layoutFixedWidth': string;
+    'fabric.editor.layoutFullWidth': string;
+    'fabric.editor.layoutWide': string;
+    'fabric.editor.link': string;
+    'fabric.editor.link.description': string;
+    'fabric.editor.mediaFiles': string;
+    'fabric.editor.mediaFiles.description': string;
+    'fabric.editor.mention': string;
+    'fabric.editor.mention.description': string;
+    'fabric.editor.openLink': string;
+    'fabric.editor.placeholderText': string;
+    'fabric.editor.placeholderText.description': string;
+    'fabric.editor.remove': string;
+    'fabric.editor.removeEmoji': string;
+    'fabric.editor.saveButton': string;
+    'fabric.editor.status': string;
+    'fabric.editor.status.description': string;
+    'fabric.editor.table': string;
+    'fabric.editor.table.description': string;
+    'fabric.editor.time.ago': string;
+    'fabric.editor.time.updated': string;
+    'fabric.editor.time.viewed': string;
+    'fabric.editor.tooltip.blockPanel': string;
+    'fabric.editor.tooltip.bulletList': string;
+    'fabric.editor.tooltip.decisionList': string;
+    'fabric.editor.tooltip.defaultBlockNode': string;
+    'fabric.editor.tooltip.nestedExpand': string;
+    'fabric.editor.tooltip.taskList': string;
+    'fabric.editor.unsupportedBlockContent': string;
+    'fabric.editor.unsupportedContentTooltip': string;
+    'fabric.editor.unsupportedInlineContent': string;
+    'fabric.editor.viewMore': string;
+    'fabric.editor.visit': string;
+    'fabric.theme.blue': string;
+    'fabric.theme.bold-blue': string;
+    'fabric.theme.bold-gray': string;
+    'fabric.theme.bold-green': string;
+    'fabric.theme.bold-magenta': string;
+    'fabric.theme.bold-orange': string;
+    'fabric.theme.bold-purple': string;
+    'fabric.theme.bold-red': string;
+    'fabric.theme.bold-teal': string;
+    'fabric.theme.bold-yellow': string;
+    'fabric.theme.bolder-blue': string;
+    'fabric.theme.bolder-gray': string;
+    'fabric.theme.bolder-green': string;
+    'fabric.theme.bolder-magenta': string;
+    'fabric.theme.bolder-orange': string;
+    'fabric.theme.bolder-purple': string;
+    'fabric.theme.bolder-red': string;
+    'fabric.theme.bolder-teal': string;
+    'fabric.theme.bolder-yellow': string;
+    'fabric.theme.dark-blue': string;
+    'fabric.theme.dark-gray': string;
+    'fabric.theme.dark-green': string;
+    'fabric.theme.dark-purple': string;
+    'fabric.theme.dark-red': string;
+    'fabric.theme.dark-teal': string;
+    'fabric.theme.dark-yellow': string;
+    'fabric.theme.default': string;
+    'fabric.theme.gray': string;
+    'fabric.theme.green': string;
+    'fabric.theme.light-blue': string;
+    'fabric.theme.light-gray': string;
+    'fabric.theme.light-green': string;
+    'fabric.theme.light-purple': string;
+    'fabric.theme.light-red': string;
+    'fabric.theme.light-teal': string;
+    'fabric.theme.light-yellow': string;
+    'fabric.theme.magenta': string;
+    'fabric.theme.orange': string;
+    'fabric.theme.purple': string;
+    'fabric.theme.red': string;
+    'fabric.theme.subtle-blue': string;
+    'fabric.theme.subtle-gray': string;
+    'fabric.theme.subtle-green': string;
+    'fabric.theme.subtle-magenta': string;
+    'fabric.theme.subtle-orange': string;
+    'fabric.theme.subtle-purple': string;
+    'fabric.theme.subtle-red': string;
+    'fabric.theme.subtle-teal': string;
+    'fabric.theme.subtle-yellow': string;
+    'fabric.theme.teal': string;
+    'fabric.theme.white': string;
+    'fabric.theme.yellow': string;
+};
+export default _default;