BookStack Code Mirror - bookstack/blobdiff - public/libs/tinymce/tinymce.d.ts

isFakeCaret?: boolean;

forward?: boolean;

}

isFakeCaret?: boolean;

forward?: boolean;

}

-declare type Bookmark = StringPathBookmark | RangeBookmark | IdBookmark | IndexBookmark | PathBookmark;

-declare type NormalizedEvent<E, T = any> = E & {

+type Bookmark = StringPathBookmark | RangeBookmark | IdBookmark | IndexBookmark | PathBookmark;

+type NormalizedEvent<E, T = any> = E & {

readonly type: string;

readonly target: T;

readonly isDefaultPrevented: () => boolean;

readonly type: string;

readonly target: T;

readonly isDefaultPrevented: () => boolean;

readonly isImmediatePropagationStopped: () => boolean;

readonly stopImmediatePropagation: () => void;

};

readonly isImmediatePropagationStopped: () => boolean;

readonly stopImmediatePropagation: () => void;

};

-declare type MappedEvent<T, K extends string> = K extends keyof T ? T[K] : any;

+type MappedEvent<T extends {}, K extends string> = K extends keyof T ? T[K] : any;

interface NativeEventMap {

'beforepaste': Event;

'blur': FocusEvent;

interface NativeEventMap {

'beforepaste': Event;

'blur': FocusEvent;

'touchcancel': TouchEvent;

'wheel': WheelEvent;

}

'touchcancel': TouchEvent;

'wheel': WheelEvent;

}

-declare type EditorEvent<T> = NormalizedEvent<T>;

+type EditorEvent<T> = NormalizedEvent<T>;

interface EventDispatcherSettings {

scope?: any;

toggleEvent?: (name: string, state: boolean) => void | boolean;

beforeFire?: <T>(args: EditorEvent<T>) => void;

}

interface EventDispatcherSettings {

scope?: any;

toggleEvent?: (name: string, state: boolean) => void | boolean;

beforeFire?: <T>(args: EditorEvent<T>) => void;

}

-interface EventDispatcherConstructor<T extends NativeEventMap> {

+interface EventDispatcherConstructor<T extends {}> {

readonly prototype: EventDispatcher<T>;

new (settings?: EventDispatcherSettings): EventDispatcher<T>;

isNative: (name: string) => boolean;

}

readonly prototype: EventDispatcher<T>;

new (settings?: EventDispatcherSettings): EventDispatcher<T>;

isNative: (name: string) => boolean;

}

-declare class EventDispatcher<T> {

+declare class EventDispatcher<T extends {}> {

static isNative(name: string): boolean;

private readonly settings;

private readonly scope;

private readonly toggleEvent;

private bindings;

static isNative(name: string): boolean;

private readonly settings;

private readonly scope;

private readonly toggleEvent;

private bindings;

- constructor(settings?: Record<string, any>);

+ constructor(settings?: EventDispatcherSettings);

fire<K extends string, U extends MappedEvent<T, K>>(name: K, args?: U): EditorEvent;

dispatch<K extends string, U extends MappedEvent<T, K>>(name: K, args?: U): EditorEvent;

fire<K extends string, U extends MappedEvent<T, K>>(name: K, args?: U): EditorEvent;

dispatch<K extends string, U extends MappedEvent<T, K>>(name: K, args?: U): EditorEvent;

- on<K extends string>(name: K, callback: false | ((event: EditorEvent<MappedEvent<T, K>>) => void), prepend?: boolean, extra?: {}): this;

+ on<K extends string>(name: K, callback: false | ((event: EditorEvent<MappedEvent<T, K>>) => void | boolean), prepend?: boolean, extra?: {}): this;

off<K extends string>(name?: K, callback?: (event: EditorEvent<MappedEvent<T, K>>) => void): this;

once<K extends string>(name: K, callback: (event: EditorEvent<MappedEvent<T, K>>) => void, prepend?: boolean): this;

has(name: string): boolean;

}

off<K extends string>(name?: K, callback?: (event: EditorEvent<MappedEvent<T, K>>) => void): this;

once<K extends string>(name: K, callback: (event: EditorEvent<MappedEvent<T, K>>) => void, prepend?: boolean): this;

has(name: string): boolean;

}

-declare const enum UndoLevelType {

- Fragmented = "fragmented",

- Complete = "complete"

-}

-interface UndoLevel {

+type UndoLevelType = 'fragmented' | 'complete';

+interface BaseUndoLevel {

type: UndoLevelType;

+ bookmark: Bookmark | null;

+ beforeBookmark: Bookmark | null;

+}

+interface FragmentedUndoLevel extends BaseUndoLevel {

+ type: 'fragmented';

fragments: string[];

+ content: '';

+}

+interface CompleteUndoLevel extends BaseUndoLevel {

+ type: 'complete';

+ fragments: null;

content: string;

- bookmark: Bookmark;

- beforeBookmark: Bookmark;

}

+type NewUndoLevel = CompleteUndoLevel | FragmentedUndoLevel;

+type UndoLevel = NewUndoLevel & {

+ bookmark: Bookmark;

+};

interface UndoManager {

data: UndoLevel[];

typing: boolean;

interface UndoManager {

data: UndoLevel[];

typing: boolean;

- add: (level?: UndoLevel, event?: EditorEvent<any>) => UndoLevel;

+ add: (level?: Partial<UndoLevel>, event?: EditorEvent<any>) => UndoLevel | null;

dispatchChange: () => void;

beforeChange: () => void;

dispatchChange: () => void;

beforeChange: () => void;

- undo: () => UndoLevel;

- redo: () => UndoLevel;

+ undo: () => UndoLevel | undefined;

+ redo: () => UndoLevel | undefined;

clear: () => void;

reset: () => void;

hasUndo: () => boolean;

hasRedo: () => boolean;

clear: () => void;

reset: () => void;

hasUndo: () => boolean;

hasRedo: () => boolean;

- transact: (callback: () => void) => UndoLevel;

+ transact: (callback: () => void) => UndoLevel | null;

ignore: (callback: () => void) => void;

extra: (callback1: () => void, callback2: () => void) => void;

}

ignore: (callback: () => void) => void;

extra: (callback1: () => void, callback2: () => void) => void;

}

-declare type SchemaType = 'html4' | 'html5' | 'html5-strict';

-interface SchemaSettings {

+type SchemaType = 'html4' | 'html5' | 'html5-strict';

+interface ElementSettings {

+ block_elements?: string;

+ boolean_attributes?: string;

+ move_caret_before_on_enter_elements?: string;

+ non_empty_elements?: string;

+ self_closing_elements?: string;

+ text_block_elements?: string;

+ text_inline_elements?: string;

+ void_elements?: string;

+ whitespace_elements?: string;

+ transparent_elements?: string;

+ wrap_block_elements?: string;

+}

+interface SchemaSettings extends ElementSettings {

custom_elements?: string;

extended_valid_elements?: string;

invalid_elements?: string;

custom_elements?: string;

extended_valid_elements?: string;

invalid_elements?: string;

value: string;

}

value: string;

}

-interface AttributePattern {

- defaultValue?: string;

- forcedValue?: string;

+interface AttributePattern extends Attribute {

pattern: RegExp;

- required?: boolean;

- validValues?: Record<string, {}>;

}

interface ElementRule {

attributes: Record<string, Attribute>;

}

interface ElementRule {

attributes: Record<string, Attribute>;

getNonEmptyElements: () => SchemaMap;

getMoveCaretBeforeOnEnterElements: () => SchemaMap;

getWhitespaceElements: () => SchemaMap;

getNonEmptyElements: () => SchemaMap;

getMoveCaretBeforeOnEnterElements: () => SchemaMap;

getWhitespaceElements: () => SchemaMap;

+ getTransparentElements: () => SchemaMap;

getSpecialElements: () => SchemaRegExpMap;

isValidChild: (name: string, child: string) => boolean;

isValid: (name: string, attr?: string) => boolean;

getSpecialElements: () => SchemaRegExpMap;

isValidChild: (name: string, child: string) => boolean;

isValid: (name: string, attr?: string) => boolean;

+ isBlock: (name: string) => boolean;

+ isInline: (name: string) => boolean;

+ isWrapper: (name: string) => boolean;

getCustomElements: () => SchemaMap;

addValidElements: (validElements: string) => void;

setValidElements: (validElements: string) => void;

addCustomElements: (customElements: string) => void;

addValidChildren: (validChildren: any) => void;

}

getCustomElements: () => SchemaMap;

addValidElements: (validElements: string) => void;

setValidElements: (validElements: string) => void;

addCustomElements: (customElements: string) => void;

addValidChildren: (validChildren: any) => void;

}

-declare type Attributes$1 = Array<{

+type Attributes$1 = Array<{

value: string;

}> & {

value: string;

}> & {

type: number;

attributes?: Attributes$1;

value?: string;

type: number;

attributes?: Attributes$1;

value?: string;

- parent?: AstNode;

- firstChild?: AstNode;

- lastChild?: AstNode;

- next?: AstNode;

- prev?: AstNode;

+ parent?: AstNode | null;

+ firstChild?: AstNode | null;

+ lastChild?: AstNode | null;

+ next?: AstNode | null;

+ prev?: AstNode | null;

raw?: boolean;

constructor(name: string, type: number);

replace(node: AstNode): AstNode;

raw?: boolean;

constructor(name: string, type: number);

replace(node: AstNode): AstNode;

- attr(name: string, value: string | null): AstNode | undefined;

- attr(name: Record<string, string | null>): AstNode | undefined;

+ attr(name: string, value: string | null | undefined): AstNode | undefined;

+ attr(name: Record<string, string | null | undefined> | undefined): AstNode | undefined;

attr(name: string): string | undefined;

clone(): AstNode;

wrap(wrapper: AstNode): AstNode;

attr(name: string): string | undefined;

clone(): AstNode;

wrap(wrapper: AstNode): AstNode;

children(): AstNode[];

empty(): AstNode;

isEmpty(elements: SchemaMap, whitespace?: SchemaMap, predicate?: (node: AstNode) => boolean): boolean;

children(): AstNode[];

empty(): AstNode;

isEmpty(elements: SchemaMap, whitespace?: SchemaMap, predicate?: (node: AstNode) => boolean): boolean;

- walk(prev?: boolean): AstNode;

+ walk(prev?: boolean): AstNode | null | undefined;

}

-declare type Content = string | AstNode;

-declare type ContentFormat = 'raw' | 'text' | 'html' | 'tree';

+type Content = string | AstNode;

+type ContentFormat = 'raw' | 'text' | 'html' | 'tree';

interface GetContentArgs {

format: ContentFormat;

get: boolean;

interface GetContentArgs {

format: ContentFormat;

get: boolean;

no_events?: boolean;

no_selection?: boolean;

paste?: boolean;

no_events?: boolean;

no_selection?: boolean;

paste?: boolean;

+ load?: boolean;

+ initial?: boolean;

+ [key: string]: any;

}

interface GetSelectionContentArgs extends GetContentArgs {

selection?: boolean;

}

interface GetSelectionContentArgs extends GetContentArgs {

selection?: boolean;

private readonly editor;

private lastPath;

constructor(editor: Editor);

private readonly editor;

private lastPath;

constructor(editor: Editor);

- nodeChanged(args?: any): void;

+ nodeChanged(args?: Record<string, any>): void;

private isSameElementPath;

}

interface SelectionOverrides {

private isSameElementPath;

}

interface SelectionOverrides {

- showCaret: (direction: number, node: Element, before: boolean, scrollIntoView?: boolean) => Range | null;

- showBlockCaretContainer: (blockCaretContainer: Element) => void;

+ showCaret: (direction: number, node: HTMLElement, before: boolean, scrollIntoView?: boolean) => Range | null;

+ showBlockCaretContainer: (blockCaretContainer: HTMLElement) => void;

hideFakeCaret: () => void;

destroy: () => void;

}

hideFakeCaret: () => void;

destroy: () => void;

}

refreshContentEditable(): void;

isHidden(): boolean;

}

refreshContentEditable(): void;

isHidden(): boolean;

}

-declare type DecoratorData = Record<string, any>;

-declare type Decorator = (uid: string, data: DecoratorData) => {

+type DecoratorData = Record<string, any>;

+type Decorator = (uid: string, data: DecoratorData) => {

attributes?: {};

classes?: string[];

};

attributes?: {};

classes?: string[];

};

-declare type AnnotationListener = (state: boolean, name: string, data?: {

+type AnnotationListener = (state: boolean, name: string, data?: {

uid: string;

nodes: any[];

}) => void;

uid: string;

nodes: any[];

}) => void;

-declare type AnnotationListenerApi = AnnotationListener;

+type AnnotationListenerApi = AnnotationListener;

interface AnnotatorSettings {

decorate: Decorator;

persistent?: boolean;

interface AnnotatorSettings {

decorate: Decorator;

persistent?: boolean;

fromClientRect: (clientRect: DOMRect) => GeomRect;

}

interface NotificationManagerImpl {

fromClientRect: (clientRect: DOMRect) => GeomRect;

}

interface NotificationManagerImpl {

- open: (spec: NotificationSpec, closeCallback?: () => void) => NotificationApi;

+ open: (spec: NotificationSpec, closeCallback: () => void) => NotificationApi;

close: <T extends NotificationApi>(notification: T) => void;

getArgs: <T extends NotificationApi>(notification: T) => NotificationSpec;

}

close: <T extends NotificationApi>(notification: T) => void;

getArgs: <T extends NotificationApi>(notification: T) => NotificationSpec;

}

message: string;

remove?: boolean;

}

message: string;

remove?: boolean;

}

-declare type ProgressFn = (percent: number) => void;

-declare type UploadHandler = (blobInfo: BlobInfo, progress: ProgressFn) => Promise<string>;

+type ProgressFn = (percent: number) => void;

+type UploadHandler = (blobInfo: BlobInfo, progress: ProgressFn) => Promise<string>;

interface UploadResult$2 {

url: string;

blobInfo: BlobInfo;

interface UploadResult$2 {

url: string;

blobInfo: BlobInfo;

readonly cmd: string;

readonly value?: any;

}

readonly cmd: string;

readonly value?: any;

}

-declare type InlinePattern = InlineFormatPattern | InlineCmdPattern;

+type InlinePattern = InlineFormatPattern | InlineCmdPattern;

interface BlockBasePattern {

readonly start: string;

}

interface BlockBasePattern {

readonly start: string;

}

readonly cmd: string;

readonly value?: any;

}

readonly cmd: string;

readonly value?: any;

}

-declare type BlockPattern = BlockFormatPattern | BlockCmdPattern;

-declare type Pattern = InlinePattern | BlockPattern;

+type BlockPattern = BlockFormatPattern | BlockCmdPattern;

+type Pattern = InlinePattern | BlockPattern;

+interface DynamicPatternContext {

+ readonly text: string;

+ readonly block: Element;

+}

+type DynamicPatternsLookup = (ctx: DynamicPatternContext) => Pattern[];

+type RawDynamicPatternsLookup = (ctx: DynamicPatternContext) => RawPattern[];

interface AlertBannerSpec {

type: 'alertbanner';

level: 'info' | 'warn' | 'error' | 'success';

interface AlertBannerSpec {

type: 'alertbanner';

level: 'info' | 'warn' | 'error' | 'success';

}

interface ColorInputSpec extends FormComponentWithLabelSpec {

type: 'colorinput';

}

interface ColorInputSpec extends FormComponentWithLabelSpec {

type: 'colorinput';

+ storageKey?: string;

}

interface ColorPickerSpec extends FormComponentWithLabelSpec {

type: 'colorpicker';

}

interface ColorPickerSpec extends FormComponentWithLabelSpec {

type: 'colorpicker';

getValue: () => string;

destroy: () => void;

}

getValue: () => string;

destroy: () => void;

}

-declare type CustomEditorInitFn = (elm: HTMLElement, settings: any) => Promise<CustomEditorInit>;

+type CustomEditorInitFn = (elm: HTMLElement, settings: any) => Promise<CustomEditorInit>;

interface CustomEditorOldSpec extends FormComponentSpec {

type: 'customeditor';

tag?: string;

interface CustomEditorOldSpec extends FormComponentSpec {

type: 'customeditor';

tag?: string;

scriptUrl: string;

settings?: any;

}

scriptUrl: string;

settings?: any;

}

-declare type CustomEditorSpec = CustomEditorOldSpec | CustomEditorNewSpec;

+type CustomEditorSpec = CustomEditorOldSpec | CustomEditorNewSpec;

interface DropZoneSpec extends FormComponentWithLabelSpec {

type: 'dropzone';

}

interface DropZoneSpec extends FormComponentWithLabelSpec {

type: 'dropzone';

}

interface IframeSpec extends FormComponentWithLabelSpec {

type: 'iframe';

}

interface IframeSpec extends FormComponentWithLabelSpec {

type: 'iframe';

+ border?: boolean;

sandboxed?: boolean;

+ streamContent?: boolean;

transparent?: boolean;

}

interface ImagePreviewSpec extends FormComponentSpec {

transparent?: boolean;

}

interface ImagePreviewSpec extends FormComponentSpec {

maximized?: boolean;

enabled?: boolean;

}

maximized?: boolean;

enabled?: boolean;

}

+type Alignment = 'start' | 'center' | 'end';

interface LabelSpec {

type: 'label';

label: string;

items: BodyComponentSpec[];

interface LabelSpec {

type: 'label';

label: string;

items: BodyComponentSpec[];

+ align?: Alignment;

}

interface ListBoxSingleItemSpec {

text: string;

}

interface ListBoxSingleItemSpec {

text: string;

items: ListBoxItemSpec[];

}

text: string;

items: ListBoxItemSpec[];

}

-declare type ListBoxItemSpec = ListBoxNestedItemSpec | ListBoxSingleItemSpec;

+type ListBoxItemSpec = ListBoxNestedItemSpec | ListBoxSingleItemSpec;

interface ListBoxSpec extends FormComponentWithLabelSpec {

type: 'listbox';

items: ListBoxItemSpec[];

interface ListBoxSpec extends FormComponentWithLabelSpec {

type: 'listbox';

items: ListBoxItemSpec[];

maximized?: boolean;

enabled?: boolean;

}

maximized?: boolean;

enabled?: boolean;

}

-interface UrlInputSpec extends FormComponentWithLabelSpec {

- type: 'urlinput';

- filetype?: 'image' | 'media' | 'file';

+interface BaseToolbarButtonSpec {

enabled?: boolean;

+ tooltip?: string;

+ icon?: string;

+ text?: string;

+ onSetup?: (api: I) => (api: I) => void;

}

-interface UrlInputData {

- value: string;

- meta: {

- text?: string;

- };

+interface BaseToolbarButtonInstanceApi {

+ isEnabled: () => boolean;

+ setEnabled: (state: boolean) => void;

+ setText: (text: string) => void;

+ setIcon: (icon: string) => void;

}

-interface BarSpec {

- type: 'bar';

- items: BodyComponentSpec[];

+interface ToolbarButtonSpec extends BaseToolbarButtonSpec<ToolbarButtonInstanceApi> {

+ type?: 'button';

+ onAction: (api: ToolbarButtonInstanceApi) => void;

+}

+interface ToolbarButtonInstanceApi extends BaseToolbarButtonInstanceApi {

+}

+interface ToolbarGroupSetting {

+ name: string;

+ items: string[];

+}

+type ToolbarConfig = string | ToolbarGroupSetting[];

+interface GroupToolbarButtonInstanceApi extends BaseToolbarButtonInstanceApi {

+}

+interface GroupToolbarButtonSpec extends BaseToolbarButtonSpec<GroupToolbarButtonInstanceApi> {

+ type?: 'grouptoolbarbutton';

+ items?: ToolbarConfig;

+}

+interface CardImageSpec {

+ type: 'cardimage';

+ src: string;

+ alt?: string;

+ classes?: string[];

+}

+interface CardTextSpec {

+ type: 'cardtext';

+ text: string;

+ name?: string;

+ classes?: string[];

+}

+type CardItemSpec = CardContainerSpec | CardImageSpec | CardTextSpec;

+type CardContainerDirection = 'vertical' | 'horizontal';

+type CardContainerAlign = 'left' | 'right';

+type CardContainerValign = 'top' | 'middle' | 'bottom';

+interface CardContainerSpec {

+ type: 'cardcontainer';

+ items: CardItemSpec[];

+ direction?: CardContainerDirection;

+ align?: CardContainerAlign;

+ valign?: CardContainerValign;

}

interface CommonMenuItemSpec {

enabled?: boolean;

}

interface CommonMenuItemSpec {

enabled?: boolean;

isEnabled: () => boolean;

setEnabled: (state: boolean) => void;

}

isEnabled: () => boolean;

setEnabled: (state: boolean) => void;

}

+interface CardMenuItemInstanceApi extends CommonMenuItemInstanceApi {

+}

+interface CardMenuItemSpec extends Omit<CommonMenuItemSpec, 'text' | 'shortcut'> {

+ type: 'cardmenuitem';

+ label?: string;

+ items: CardItemSpec[];

+ onSetup?: (api: CardMenuItemInstanceApi) => (api: CardMenuItemInstanceApi) => void;

+ onAction?: (api: CardMenuItemInstanceApi) => void;

+}

+interface ChoiceMenuItemSpec extends CommonMenuItemSpec {

+ type?: 'choiceitem';

+ icon?: string;

+}

+interface ChoiceMenuItemInstanceApi extends CommonMenuItemInstanceApi {

+ isActive: () => boolean;

+ setActive: (state: boolean) => void;

+}

+interface ContextMenuItem extends CommonMenuItemSpec {

+ text: string;

+ icon?: string;

+ type?: 'item';

+ onAction: () => void;

+}

+interface ContextSubMenu extends CommonMenuItemSpec {

+ type: 'submenu';

+ text: string;

+ icon?: string;

+ getSubmenuItems: () => string | Array<ContextMenuContents>;

+}

+type ContextMenuContents = string | ContextMenuItem | SeparatorMenuItemSpec | ContextSubMenu;

+interface ContextMenuApi {

+ update: (element: Element) => string | Array<ContextMenuContents>;

+}

+interface FancyActionArgsMap {

+ 'inserttable': {

+ numRows: number;

+ numColumns: number;

+ };

+ 'colorswatch': {

+ value: string;

+ };

+}

+interface BaseFancyMenuItemSpec<T extends keyof FancyActionArgsMap> {

+ type: 'fancymenuitem';

+ fancytype: T;

+ initData?: Record<string, unknown>;

+ onAction?: (data: FancyActionArgsMap[T]) => void;

+}

+interface InsertTableMenuItemSpec extends BaseFancyMenuItemSpec<'inserttable'> {

+ fancytype: 'inserttable';

+ initData?: {};

+}

+interface ColorSwatchMenuItemSpec extends BaseFancyMenuItemSpec<'colorswatch'> {

+ fancytype: 'colorswatch';

+ select?: (value: string) => boolean;

+ initData?: {

+ allowCustomColors?: boolean;

+ colors?: ChoiceMenuItemSpec[];

+ storageKey?: string;

+ };

+}

+type FancyMenuItemSpec = InsertTableMenuItemSpec | ColorSwatchMenuItemSpec;

+interface MenuItemSpec extends CommonMenuItemSpec {

+ type?: 'menuitem';

+ icon?: string;

+ onSetup?: (api: MenuItemInstanceApi) => (api: MenuItemInstanceApi) => void;

+ onAction?: (api: MenuItemInstanceApi) => void;

+}

+interface MenuItemInstanceApi extends CommonMenuItemInstanceApi {

+}

+interface SeparatorMenuItemSpec {

+ type?: 'separator';

+ text?: string;

+}

+interface ToggleMenuItemSpec extends CommonMenuItemSpec {

+ type?: 'togglemenuitem';

+ icon?: string;

+ active?: boolean;

+ onSetup?: (api: ToggleMenuItemInstanceApi) => void;

+ onAction: (api: ToggleMenuItemInstanceApi) => void;

+}

+interface ToggleMenuItemInstanceApi extends CommonMenuItemInstanceApi {

+ isActive: () => boolean;

+ setActive: (state: boolean) => void;

+}

+interface NestedMenuItemSpec extends CommonMenuItemSpec {

+ type?: 'nestedmenuitem';

+ icon?: string;

+ getSubmenuItems: () => string | Array<NestedMenuItemContents>;

+ onSetup?: (api: NestedMenuItemInstanceApi) => (api: NestedMenuItemInstanceApi) => void;

+}

+interface NestedMenuItemInstanceApi extends CommonMenuItemInstanceApi {

+ setTooltip: (tooltip: string) => void;

+ setIconFill: (id: string, value: string) => void;

+}

+type MenuButtonItemTypes = NestedMenuItemContents;

+type SuccessCallback$1 = (menu: string | MenuButtonItemTypes[]) => void;

+interface MenuButtonFetchContext {

+ pattern: string;

+}

+interface BaseMenuButtonSpec {

+ text?: string;

+ tooltip?: string;

+ icon?: string;

+ search?: boolean | {

+ placeholder?: string;

+ };

+ fetch: (success: SuccessCallback$1, fetchContext: MenuButtonFetchContext, api: BaseMenuButtonInstanceApi) => void;

+ onSetup?: (api: BaseMenuButtonInstanceApi) => (api: BaseMenuButtonInstanceApi) => void;

+}

+interface BaseMenuButtonInstanceApi {

+ isEnabled: () => boolean;

+ setEnabled: (state: boolean) => void;

+ isActive: () => boolean;

+ setActive: (state: boolean) => void;

+ setText: (text: string) => void;

+ setIcon: (icon: string) => void;

+}

+interface ToolbarMenuButtonSpec extends BaseMenuButtonSpec {

+ type?: 'menubutton';

+ onSetup?: (api: ToolbarMenuButtonInstanceApi) => (api: ToolbarMenuButtonInstanceApi) => void;

+}

+interface ToolbarMenuButtonInstanceApi extends BaseMenuButtonInstanceApi {

+}

+type ToolbarSplitButtonItemTypes = ChoiceMenuItemSpec | SeparatorMenuItemSpec;

+type SuccessCallback = (menu: ToolbarSplitButtonItemTypes[]) => void;

+type SelectPredicate = (value: string) => boolean;

+type PresetTypes = 'color' | 'normal' | 'listpreview';

+type ColumnTypes$1 = number | 'auto';

+interface ToolbarSplitButtonSpec {

+ type?: 'splitbutton';

+ tooltip?: string;

+ icon?: string;

+ text?: string;

+ select?: SelectPredicate;

+ presets?: PresetTypes;

+ columns?: ColumnTypes$1;

+ fetch: (success: SuccessCallback) => void;

+ onSetup?: (api: ToolbarSplitButtonInstanceApi) => (api: ToolbarSplitButtonInstanceApi) => void;

+ onAction: (api: ToolbarSplitButtonInstanceApi) => void;

+ onItemAction: (api: ToolbarSplitButtonInstanceApi, value: string) => void;

+}

+interface ToolbarSplitButtonInstanceApi {

+ isEnabled: () => boolean;

+ setEnabled: (state: boolean) => void;

+ setIconFill: (id: string, value: string) => void;

+ isActive: () => boolean;

+ setActive: (state: boolean) => void;

+ setTooltip: (tooltip: string) => void;

+ setText: (text: string) => void;

+ setIcon: (icon: string) => void;

+}

+interface BaseToolbarToggleButtonSpec extends BaseToolbarButtonSpec {

+ active?: boolean;

+}

+interface BaseToolbarToggleButtonInstanceApi extends BaseToolbarButtonInstanceApi {

+ isActive: () => boolean;

+ setActive: (state: boolean) => void;

+}

+interface ToolbarToggleButtonSpec extends BaseToolbarToggleButtonSpec<ToolbarToggleButtonInstanceApi> {

+ type?: 'togglebutton';

+ onAction: (api: ToolbarToggleButtonInstanceApi) => void;

+}

+interface ToolbarToggleButtonInstanceApi extends BaseToolbarToggleButtonInstanceApi {

+}

+type Id = string;

+interface TreeSpec {

+ type: 'tree';

+ items: TreeItemSpec[];

+ onLeafAction?: (id: Id) => void;

+ defaultExpandedIds?: Id[];

+ onToggleExpand?: (expandedIds: Id[], { expanded, node }: {

+ expanded: boolean;

+ node: Id;

+ }) => void;

+ defaultSelectedId?: Id;

+}

+interface BaseTreeItemSpec {

+ title: string;

+ id: Id;

+ menu?: ToolbarMenuButtonSpec;

+}

+interface DirectorySpec extends BaseTreeItemSpec {

+ type: 'directory';

+ children: TreeItemSpec[];

+}

+interface LeafSpec extends BaseTreeItemSpec {

+ type: 'leaf';

+}

+type TreeItemSpec = DirectorySpec | LeafSpec;

+interface UrlInputSpec extends FormComponentWithLabelSpec {

+ type: 'urlinput';

+ filetype?: 'image' | 'media' | 'file';

+ enabled?: boolean;

+ picker_text?: string;

+}

+interface UrlInputData {

+ value: string;

+ meta: {

+ text?: string;

+ };

+}

+interface BarSpec {

+ type: 'bar';

+ items: BodyComponentSpec[];

+}

interface DialogToggleMenuItemSpec extends CommonMenuItemSpec {

type?: 'togglemenuitem';

}

interface DialogToggleMenuItemSpec extends CommonMenuItemSpec {

type?: 'togglemenuitem';

}

-declare type DialogFooterMenuButtonItemSpec = DialogToggleMenuItemSpec;

+type DialogFooterMenuButtonItemSpec = DialogToggleMenuItemSpec;

interface BaseDialogFooterButtonSpec {

name?: string;

align?: 'start' | 'end';

interface BaseDialogFooterButtonSpec {

name?: string;

align?: 'start' | 'end';

icon?: string;

items: DialogFooterMenuButtonItemSpec[];

}

icon?: string;

items: DialogFooterMenuButtonItemSpec[];

}

-declare type DialogFooterButtonSpec = DialogFooterNormalButtonSpec | DialogFooterMenuButtonSpec;

+interface DialogFooterToggleButtonSpec extends BaseDialogFooterButtonSpec {

+ type: 'togglebutton';

+ tooltip?: string;

+ icon?: string;

+ text?: string;

+ active?: boolean;

+}

+type DialogFooterButtonSpec = DialogFooterNormalButtonSpec | DialogFooterMenuButtonSpec | DialogFooterToggleButtonSpec;

interface TabSpec {

name?: string;

title: string;

interface TabSpec {

name?: string;

title: string;

type: 'tabpanel';

tabs: TabSpec[];

}

type: 'tabpanel';

tabs: TabSpec[];

}

-declare type DialogDataItem = any;

-declare type DialogData = Record<string, DialogDataItem>;

+type DialogDataItem = any;

+type DialogData = Record<string, DialogDataItem>;

interface DialogInstanceApi<T extends DialogData> {

getData: () => T;

setData: (data: Partial<T>) => void;

interface DialogInstanceApi<T extends DialogData> {

getData: () => T;

setData: (data: Partial<T>) => void;

redial: (nu: DialogSpec<T>) => void;

block: (msg: string) => void;

unblock: () => void;

redial: (nu: DialogSpec<T>) => void;

block: (msg: string) => void;

unblock: () => void;

+ toggleFullscreen: () => void;

close: () => void;

}

interface DialogActionDetails {

close: () => void;

}

interface DialogActionDetails {

newTabName: string;

oldTabName: string;

}

newTabName: string;

oldTabName: string;

}

-declare type DialogActionHandler<T> = (api: DialogInstanceApi<T>, details: DialogActionDetails) => void;

-declare type DialogChangeHandler<T> = (api: DialogInstanceApi<T>, details: DialogChangeDetails<T>) => void;

-declare type DialogSubmitHandler<T> = (api: DialogInstanceApi<T>) => void;

-declare type DialogCloseHandler = () => void;

-declare type DialogCancelHandler<T> = (api: DialogInstanceApi<T>) => void;

-declare type DialogTabChangeHandler<T> = (api: DialogInstanceApi<T>, details: DialogTabChangeDetails) => void;

-declare type DialogSize = 'normal' | 'medium' | 'large';

+type DialogActionHandler<T extends DialogData> = (api: DialogInstanceApi<T>, details: DialogActionDetails) => void;

+type DialogChangeHandler<T extends DialogData> = (api: DialogInstanceApi<T>, details: DialogChangeDetails<T>) => void;

+type DialogSubmitHandler<T extends DialogData> = (api: DialogInstanceApi<T>) => void;

+type DialogCloseHandler = () => void;

+type DialogCancelHandler<T extends DialogData> = (api: DialogInstanceApi<T>) => void;

+type DialogTabChangeHandler<T extends DialogData> = (api: DialogInstanceApi<T>, details: DialogTabChangeDetails) => void;

+type DialogSize = 'normal' | 'medium' | 'large';

interface DialogSpec<T extends DialogData> {

title: string;

size?: DialogSize;

body: TabPanelSpec | PanelSpec;

interface DialogSpec<T extends DialogData> {

title: string;

size?: DialogSize;

body: TabPanelSpec | PanelSpec;

- buttons: DialogFooterButtonSpec[];

+ buttons?: DialogFooterButtonSpec[];

initialData?: Partial<T>;

onAction?: DialogActionHandler<T>;

onChange?: DialogChangeHandler<T>;

initialData?: Partial<T>;

onAction?: DialogActionHandler<T>;

onChange?: DialogChangeHandler<T>;

mceAction: string;

[key: string]: any;

}

mceAction: string;

[key: string]: any;

}

-declare type UrlDialogActionHandler = (api: UrlDialogInstanceApi, actions: UrlDialogActionDetails) => void;

-declare type UrlDialogCloseHandler = () => void;

-declare type UrlDialogCancelHandler = (api: UrlDialogInstanceApi) => void;

-declare type UrlDialogMessageHandler = (api: UrlDialogInstanceApi, message: UrlDialogMessage) => void;

+type UrlDialogActionHandler = (api: UrlDialogInstanceApi, actions: UrlDialogActionDetails) => void;

+type UrlDialogCloseHandler = () => void;

+type UrlDialogCancelHandler = (api: UrlDialogInstanceApi) => void;

+type UrlDialogMessageHandler = (api: UrlDialogInstanceApi, message: UrlDialogMessage) => void;

interface UrlDialogFooterButtonSpec extends DialogFooterNormalButtonSpec {

type: 'cancel' | 'custom';

}

interface UrlDialogFooterButtonSpec extends DialogFooterNormalButtonSpec {

type: 'cancel' | 'custom';

}

onCancel?: UrlDialogCancelHandler;

onMessage?: UrlDialogMessageHandler;

}

onCancel?: UrlDialogCancelHandler;

onMessage?: UrlDialogMessageHandler;

}

-declare type CardContainerDirection = 'vertical' | 'horizontal';

-declare type CardContainerAlign = 'left' | 'right';

-declare type CardContainerValign = 'top' | 'middle' | 'bottom';

-interface CardContainerSpec {

- type: 'cardcontainer';

- items: CardItemSpec[];

- direction?: CardContainerDirection;

- align?: CardContainerAlign;

- valign?: CardContainerValign;

-}

-interface CardImageSpec {

- type: 'cardimage';

- src: string;

- alt?: string;

- classes?: string[];

-}

-interface CardTextSpec {

- type: 'cardtext';

- text: string;

- name?: string;

- classes?: string[];

-}

-declare type CardItemSpec = CardContainerSpec | CardImageSpec | CardTextSpec;

-interface CardMenuItemInstanceApi extends CommonMenuItemInstanceApi {

-}

-interface CardMenuItemSpec extends Omit<CommonMenuItemSpec, 'text' | 'shortcut'> {

- type: 'cardmenuitem';

- label?: string;

- items: CardItemSpec[];

- onSetup?: (api: CardMenuItemInstanceApi) => (api: CardMenuItemInstanceApi) => void;

- onAction?: (api: CardMenuItemInstanceApi) => void;

-}

-interface SeparatorMenuItemSpec {

- type?: 'separator';

- text?: string;

-}

-declare type ColumnTypes$1 = number | 'auto';

-declare type SeparatorItemSpec = SeparatorMenuItemSpec;

+type ColumnTypes = number | 'auto';

+type SeparatorItemSpec = SeparatorMenuItemSpec;

interface AutocompleterItemSpec {

type?: 'autocompleteitem';

value: string;

interface AutocompleterItemSpec {

type?: 'autocompleteitem';

value: string;

icon?: string;

meta?: Record<string, any>;

}

icon?: string;

meta?: Record<string, any>;

}

-declare type AutocompleterContents = SeparatorItemSpec | AutocompleterItemSpec | CardMenuItemSpec;

+type AutocompleterContents = SeparatorItemSpec | AutocompleterItemSpec | CardMenuItemSpec;

interface AutocompleterSpec {

type?: 'autocompleter';

interface AutocompleterSpec {

type?: 'autocompleter';

- ch: string;

+ ch?: string;

+ trigger?: string;

minChars?: number;

- columns?: ColumnTypes$1;

+ columns?: ColumnTypes;

matches?: (rng: Range, text: string, pattern: string) => boolean;

fetch: (pattern: string, maxResults: number, fetchOptions: Record<string, any>) => Promise<AutocompleterContents[]>;

onAction: (autocompleterApi: AutocompleterInstanceApi, rng: Range, value: string, meta: Record<string, any>) => void;

matches?: (rng: Range, text: string, pattern: string) => boolean;

fetch: (pattern: string, maxResults: number, fetchOptions: Record<string, any>) => Promise<AutocompleterContents[]>;

onAction: (autocompleterApi: AutocompleterInstanceApi, rng: Range, value: string, meta: Record<string, any>) => void;

hide: () => void;

reload: (fetchOptions: Record<string, any>) => void;

}

hide: () => void;

reload: (fetchOptions: Record<string, any>) => void;

}

-declare type ContextPosition = 'node' | 'selection' | 'line';

-declare type ContextScope = 'node' | 'editor';

+type ContextPosition = 'node' | 'selection' | 'line';

+type ContextScope = 'node' | 'editor';

interface ContextBarSpec {

predicate?: (elem: Element) => boolean;

position?: ContextPosition;

scope?: ContextScope;

}

interface ContextBarSpec {

predicate?: (elem: Element) => boolean;

position?: ContextPosition;

scope?: ContextScope;

}

-interface BaseToolbarButtonSpec {

- enabled?: boolean;

- tooltip?: string;

- icon?: string;

- text?: string;

- onSetup?: (api: I) => (api: I) => void;

-}

-interface BaseToolbarButtonInstanceApi {

- isEnabled: () => boolean;

- setEnabled: (state: boolean) => void;

-}

-interface ToolbarButtonSpec extends BaseToolbarButtonSpec<ToolbarButtonInstanceApi> {

- type?: 'button';

- onAction: (api: ToolbarButtonInstanceApi) => void;

-}

-interface ToolbarButtonInstanceApi extends BaseToolbarButtonInstanceApi {

-}

-interface BaseToolbarToggleButtonSpec extends BaseToolbarButtonSpec {

- active?: boolean;

-}

-interface BaseToolbarToggleButtonInstanceApi extends BaseToolbarButtonInstanceApi {

- isActive: () => boolean;

- setActive: (state: boolean) => void;

-}

-interface ToolbarToggleButtonSpec extends BaseToolbarToggleButtonSpec<ToolbarToggleButtonInstanceApi> {

- type?: 'togglebutton';

- onAction: (api: ToolbarToggleButtonInstanceApi) => void;

-}

-interface ToolbarToggleButtonInstanceApi extends BaseToolbarToggleButtonInstanceApi {

-}

interface ContextFormLaunchButtonApi extends BaseToolbarButtonSpec<BaseToolbarButtonInstanceApi> {

type: 'contextformbutton';

}

interface ContextFormLaunchButtonApi extends BaseToolbarButtonSpec<BaseToolbarButtonInstanceApi> {

type: 'contextformbutton';

}

type?: 'contexttoolbar';

items: string;

}

type?: 'contexttoolbar';

items: string;

}

-interface ChoiceMenuItemSpec extends CommonMenuItemSpec {

- type?: 'choiceitem';

- icon?: string;

-}

-interface ChoiceMenuItemInstanceApi extends CommonMenuItemInstanceApi {

- isActive: () => boolean;

- setActive: (state: boolean) => void;

-}

-interface ContextMenuItem extends CommonMenuItemSpec {

- text: string;

- icon?: string;

- type?: 'item';

- onAction: () => void;

-}

-interface ContextSubMenu extends CommonMenuItemSpec {

- type: 'submenu';

- text: string;

- icon?: string;

- getSubmenuItems: () => string | Array<ContextMenuContents>;

-}

-declare type ContextMenuContents = string | ContextMenuItem | SeparatorMenuItemSpec | ContextSubMenu;

-interface ContextMenuApi {

- update: (element: Element) => string | Array<ContextMenuContents>;

-}

-interface FancyActionArgsMap {

- 'inserttable': {

- numRows: number;

- numColumns: number;

- };

- 'colorswatch': {

- value: string;

- };

-}

-interface BaseFancyMenuItemSpec<T extends keyof FancyActionArgsMap> {

- type: 'fancymenuitem';

- fancytype: T;

- initData?: Record<string, unknown>;

- onAction?: (data: FancyActionArgsMap[T]) => void;

-}

-interface InsertTableMenuItemSpec extends BaseFancyMenuItemSpec<'inserttable'> {

- fancytype: 'inserttable';

- initData?: {};

-}

-interface ColorSwatchMenuItemSpec extends BaseFancyMenuItemSpec<'colorswatch'> {

- fancytype: 'colorswatch';

- initData?: {

- allowCustomColors?: boolean;

- colors: ChoiceMenuItemSpec[];

- };

-}

-declare type FancyMenuItemSpec = InsertTableMenuItemSpec | ColorSwatchMenuItemSpec;

-interface MenuItemSpec extends CommonMenuItemSpec {

- type?: 'menuitem';

- icon?: string;

- onSetup?: (api: MenuItemInstanceApi) => (api: MenuItemInstanceApi) => void;

- onAction?: (api: MenuItemInstanceApi) => void;

-}

-interface MenuItemInstanceApi extends CommonMenuItemInstanceApi {

-}

-interface NestedMenuItemSpec extends CommonMenuItemSpec {

- type?: 'nestedmenuitem';

- icon?: string;

- getSubmenuItems: () => string | Array<NestedMenuItemContents>;

- onSetup?: (api: NestedMenuItemInstanceApi) => (api: NestedMenuItemInstanceApi) => void;

-}

-interface NestedMenuItemInstanceApi extends CommonMenuItemInstanceApi {

-}

-interface ToggleMenuItemSpec extends CommonMenuItemSpec {

- type?: 'togglemenuitem';

- icon?: string;

- active?: boolean;

- onSetup?: (api: ToggleMenuItemInstanceApi) => void;

- onAction: (api: ToggleMenuItemInstanceApi) => void;

-}

-interface ToggleMenuItemInstanceApi extends CommonMenuItemInstanceApi {

- isActive: () => boolean;

- setActive: (state: boolean) => void;

-}

type PublicDialog_d_AlertBannerSpec = AlertBannerSpec;

type PublicDialog_d_BarSpec = BarSpec;

type PublicDialog_d_BodyComponentSpec = BodyComponentSpec;

type PublicDialog_d_AlertBannerSpec = AlertBannerSpec;

type PublicDialog_d_BarSpec = BarSpec;

type PublicDialog_d_BodyComponentSpec = BodyComponentSpec;

type PublicDialog_d_CustomEditorInitFn = CustomEditorInitFn;

type PublicDialog_d_DialogData = DialogData;

type PublicDialog_d_DialogSize = DialogSize;

type PublicDialog_d_CustomEditorInitFn = CustomEditorInitFn;

type PublicDialog_d_DialogData = DialogData;

type PublicDialog_d_DialogSize = DialogSize;

-type PublicDialog_d_DialogSpec<_0> = DialogSpec<_0>;

-type PublicDialog_d_DialogInstanceApi<_0> = DialogInstanceApi<_0>;

+type PublicDialog_d_DialogSpec<T extends DialogData> = DialogSpec<T>;

+type PublicDialog_d_DialogInstanceApi<T extends DialogData> = DialogInstanceApi<T>;

type PublicDialog_d_DialogFooterButtonSpec = DialogFooterButtonSpec;

type PublicDialog_d_DialogActionDetails = DialogActionDetails;

type PublicDialog_d_DialogFooterButtonSpec = DialogFooterButtonSpec;

type PublicDialog_d_DialogActionDetails = DialogActionDetails;

-type PublicDialog_d_DialogChangeDetails<_0> = DialogChangeDetails<_0>;

+type PublicDialog_d_DialogChangeDetails<T> = DialogChangeDetails<T>;

type PublicDialog_d_DialogTabChangeDetails = DialogTabChangeDetails;

type PublicDialog_d_DropZoneSpec = DropZoneSpec;

type PublicDialog_d_GridSpec = GridSpec;

type PublicDialog_d_DialogTabChangeDetails = DialogTabChangeDetails;

type PublicDialog_d_DropZoneSpec = DropZoneSpec;

type PublicDialog_d_GridSpec = GridSpec;

type PublicDialog_d_TabSpec = TabSpec;

type PublicDialog_d_TabPanelSpec = TabPanelSpec;

type PublicDialog_d_TextAreaSpec = TextAreaSpec;

type PublicDialog_d_TabSpec = TabSpec;

type PublicDialog_d_TabPanelSpec = TabPanelSpec;

type PublicDialog_d_TextAreaSpec = TextAreaSpec;

+type PublicDialog_d_TreeSpec = TreeSpec;

+type PublicDialog_d_TreeItemSpec = TreeItemSpec;

type PublicDialog_d_UrlInputData = UrlInputData;

type PublicDialog_d_UrlInputSpec = UrlInputSpec;

type PublicDialog_d_UrlDialogSpec = UrlDialogSpec;

type PublicDialog_d_UrlInputData = UrlInputData;

type PublicDialog_d_UrlInputSpec = UrlInputSpec;

type PublicDialog_d_UrlDialogSpec = UrlDialogSpec;

type PublicDialog_d_UrlDialogActionDetails = UrlDialogActionDetails;

type PublicDialog_d_UrlDialogMessage = UrlDialogMessage;

declare namespace PublicDialog_d {

type PublicDialog_d_UrlDialogActionDetails = UrlDialogActionDetails;

type PublicDialog_d_UrlDialogMessage = UrlDialogMessage;

declare namespace PublicDialog_d {

- export { PublicDialog_d_AlertBannerSpec as AlertBannerSpec, PublicDialog_d_BarSpec as BarSpec, PublicDialog_d_BodyComponentSpec as BodyComponentSpec, PublicDialog_d_ButtonSpec as ButtonSpec, PublicDialog_d_CheckboxSpec as CheckboxSpec, PublicDialog_d_CollectionItem as CollectionItem, PublicDialog_d_CollectionSpec as CollectionSpec, PublicDialog_d_ColorInputSpec as ColorInputSpec, PublicDialog_d_ColorPickerSpec as ColorPickerSpec, PublicDialog_d_CustomEditorSpec as CustomEditorSpec, PublicDialog_d_CustomEditorInit as CustomEditorInit, PublicDialog_d_CustomEditorInitFn as CustomEditorInitFn, PublicDialog_d_DialogData as DialogData, PublicDialog_d_DialogSize as DialogSize, PublicDialog_d_DialogSpec as DialogSpec, PublicDialog_d_DialogInstanceApi as DialogInstanceApi, PublicDialog_d_DialogFooterButtonSpec as DialogFooterButtonSpec, PublicDialog_d_DialogActionDetails as DialogActionDetails, PublicDialog_d_DialogChangeDetails as DialogChangeDetails, PublicDialog_d_DialogTabChangeDetails as DialogTabChangeDetails, PublicDialog_d_DropZoneSpec as DropZoneSpec, PublicDialog_d_GridSpec as GridSpec, PublicDialog_d_HtmlPanelSpec as HtmlPanelSpec, PublicDialog_d_IframeSpec as IframeSpec, PublicDialog_d_ImagePreviewSpec as ImagePreviewSpec, PublicDialog_d_InputSpec as InputSpec, PublicDialog_d_LabelSpec as LabelSpec, PublicDialog_d_ListBoxSpec as ListBoxSpec, PublicDialog_d_ListBoxItemSpec as ListBoxItemSpec, PublicDialog_d_ListBoxNestedItemSpec as ListBoxNestedItemSpec, PublicDialog_d_ListBoxSingleItemSpec as ListBoxSingleItemSpec, PublicDialog_d_PanelSpec as PanelSpec, PublicDialog_d_SelectBoxSpec as SelectBoxSpec, PublicDialog_d_SelectBoxItemSpec as SelectBoxItemSpec, PublicDialog_d_SizeInputSpec as SizeInputSpec, PublicDialog_d_SliderSpec as SliderSpec, PublicDialog_d_TableSpec as TableSpec, PublicDialog_d_TabSpec as TabSpec, PublicDialog_d_TabPanelSpec as TabPanelSpec, PublicDialog_d_TextAreaSpec as TextAreaSpec, PublicDialog_d_UrlInputData as UrlInputData, PublicDialog_d_UrlInputSpec as UrlInputSpec, PublicDialog_d_UrlDialogSpec as UrlDialogSpec, PublicDialog_d_UrlDialogFooterButtonSpec as UrlDialogFooterButtonSpec, PublicDialog_d_UrlDialogInstanceApi as UrlDialogInstanceApi, PublicDialog_d_UrlDialogActionDetails as UrlDialogActionDetails, PublicDialog_d_UrlDialogMessage as UrlDialogMessage, };

+ export { PublicDialog_d_AlertBannerSpec as AlertBannerSpec, PublicDialog_d_BarSpec as BarSpec, PublicDialog_d_BodyComponentSpec as BodyComponentSpec, PublicDialog_d_ButtonSpec as ButtonSpec, PublicDialog_d_CheckboxSpec as CheckboxSpec, PublicDialog_d_CollectionItem as CollectionItem, PublicDialog_d_CollectionSpec as CollectionSpec, PublicDialog_d_ColorInputSpec as ColorInputSpec, PublicDialog_d_ColorPickerSpec as ColorPickerSpec, PublicDialog_d_CustomEditorSpec as CustomEditorSpec, PublicDialog_d_CustomEditorInit as CustomEditorInit, PublicDialog_d_CustomEditorInitFn as CustomEditorInitFn, PublicDialog_d_DialogData as DialogData, PublicDialog_d_DialogSize as DialogSize, PublicDialog_d_DialogSpec as DialogSpec, PublicDialog_d_DialogInstanceApi as DialogInstanceApi, PublicDialog_d_DialogFooterButtonSpec as DialogFooterButtonSpec, PublicDialog_d_DialogActionDetails as DialogActionDetails, PublicDialog_d_DialogChangeDetails as DialogChangeDetails, PublicDialog_d_DialogTabChangeDetails as DialogTabChangeDetails, PublicDialog_d_DropZoneSpec as DropZoneSpec, PublicDialog_d_GridSpec as GridSpec, PublicDialog_d_HtmlPanelSpec as HtmlPanelSpec, PublicDialog_d_IframeSpec as IframeSpec, PublicDialog_d_ImagePreviewSpec as ImagePreviewSpec, PublicDialog_d_InputSpec as InputSpec, PublicDialog_d_LabelSpec as LabelSpec, PublicDialog_d_ListBoxSpec as ListBoxSpec, PublicDialog_d_ListBoxItemSpec as ListBoxItemSpec, PublicDialog_d_ListBoxNestedItemSpec as ListBoxNestedItemSpec, PublicDialog_d_ListBoxSingleItemSpec as ListBoxSingleItemSpec, PublicDialog_d_PanelSpec as PanelSpec, PublicDialog_d_SelectBoxSpec as SelectBoxSpec, PublicDialog_d_SelectBoxItemSpec as SelectBoxItemSpec, PublicDialog_d_SizeInputSpec as SizeInputSpec, PublicDialog_d_SliderSpec as SliderSpec, PublicDialog_d_TableSpec as TableSpec, PublicDialog_d_TabSpec as TabSpec, PublicDialog_d_TabPanelSpec as TabPanelSpec, PublicDialog_d_TextAreaSpec as TextAreaSpec, PublicDialog_d_TreeSpec as TreeSpec, PublicDialog_d_TreeItemSpec as TreeItemSpec, DirectorySpec as TreeDirectorySpec, LeafSpec as TreeLeafSpec, PublicDialog_d_UrlInputData as UrlInputData, PublicDialog_d_UrlInputSpec as UrlInputSpec, PublicDialog_d_UrlDialogSpec as UrlDialogSpec, PublicDialog_d_UrlDialogFooterButtonSpec as UrlDialogFooterButtonSpec, PublicDialog_d_UrlDialogInstanceApi as UrlDialogInstanceApi, PublicDialog_d_UrlDialogActionDetails as UrlDialogActionDetails, PublicDialog_d_UrlDialogMessage as UrlDialogMessage, };

}

type PublicInlineContent_d_AutocompleterSpec = AutocompleterSpec;

type PublicInlineContent_d_AutocompleterItemSpec = AutocompleterItemSpec;

}

type PublicInlineContent_d_AutocompleterSpec = AutocompleterSpec;

type PublicInlineContent_d_AutocompleterItemSpec = AutocompleterItemSpec;

declare namespace PublicSidebar_d {

export { PublicSidebar_d_SidebarSpec as SidebarSpec, PublicSidebar_d_SidebarInstanceApi as SidebarInstanceApi, };

}

declare namespace PublicSidebar_d {

export { PublicSidebar_d_SidebarSpec as SidebarSpec, PublicSidebar_d_SidebarInstanceApi as SidebarInstanceApi, };

}

-interface ToolbarGroupSetting {

- name: string;

- items: string[];

-}

-declare type ToolbarConfig = string | ToolbarGroupSetting[];

-interface GroupToolbarButtonInstanceApi extends BaseToolbarButtonInstanceApi {

-}

-interface GroupToolbarButtonSpec extends BaseToolbarButtonSpec<GroupToolbarButtonInstanceApi> {

- type?: 'grouptoolbarbutton';

- items?: ToolbarConfig;

-}

-declare type MenuButtonItemTypes = NestedMenuItemContents;

-declare type SuccessCallback$1 = (menu: string | MenuButtonItemTypes[]) => void;

-interface BaseMenuButtonSpec {

- text?: string;

- tooltip?: string;

- icon?: string;

- fetch: (success: SuccessCallback$1) => void;

- onSetup?: (api: BaseMenuButtonInstanceApi) => (api: BaseMenuButtonInstanceApi) => void;

-}

-interface BaseMenuButtonInstanceApi {

- isEnabled: () => boolean;

- setEnabled: (state: boolean) => void;

- isActive: () => boolean;

- setActive: (state: boolean) => void;

-}

-interface ToolbarMenuButtonSpec extends BaseMenuButtonSpec {

- type?: 'menubutton';

- onSetup?: (api: ToolbarMenuButtonInstanceApi) => (api: ToolbarMenuButtonInstanceApi) => void;

-}

-interface ToolbarMenuButtonInstanceApi extends BaseMenuButtonInstanceApi {

-}

-declare type ToolbarSplitButtonItemTypes = ChoiceMenuItemSpec | SeparatorMenuItemSpec;

-declare type SuccessCallback = (menu: ToolbarSplitButtonItemTypes[]) => void;

-declare type SelectPredicate = (value: string) => boolean;

-declare type PresetTypes = 'color' | 'normal' | 'listpreview';

-declare type ColumnTypes = number | 'auto';

-interface ToolbarSplitButtonSpec {

- type?: 'splitbutton';

- tooltip?: string;

- icon?: string;

- text?: string;

- select?: SelectPredicate;

- presets?: PresetTypes;

- columns?: ColumnTypes;

- fetch: (success: SuccessCallback) => void;

- onSetup?: (api: ToolbarSplitButtonInstanceApi) => (api: ToolbarSplitButtonInstanceApi) => void;

- onAction: (api: ToolbarSplitButtonInstanceApi) => void;

- onItemAction: (api: ToolbarSplitButtonInstanceApi, value: string) => void;

-}

-interface ToolbarSplitButtonInstanceApi {

- isEnabled: () => boolean;

- setEnabled: (state: boolean) => void;

- setIconFill: (id: string, value: string) => void;

- isActive: () => boolean;

- setActive: (state: boolean) => void;

-}

type PublicToolbar_d_ToolbarButtonSpec = ToolbarButtonSpec;

type PublicToolbar_d_ToolbarButtonInstanceApi = ToolbarButtonInstanceApi;

type PublicToolbar_d_ToolbarSplitButtonSpec = ToolbarSplitButtonSpec;

type PublicToolbar_d_ToolbarButtonSpec = ToolbarButtonSpec;

type PublicToolbar_d_ToolbarButtonInstanceApi = ToolbarButtonInstanceApi;

type PublicToolbar_d_ToolbarSplitButtonSpec = ToolbarSplitButtonSpec;

declare namespace PublicToolbar_d {

export { PublicToolbar_d_ToolbarButtonSpec as ToolbarButtonSpec, PublicToolbar_d_ToolbarButtonInstanceApi as ToolbarButtonInstanceApi, PublicToolbar_d_ToolbarSplitButtonSpec as ToolbarSplitButtonSpec, PublicToolbar_d_ToolbarSplitButtonInstanceApi as ToolbarSplitButtonInstanceApi, PublicToolbar_d_ToolbarMenuButtonSpec as ToolbarMenuButtonSpec, PublicToolbar_d_ToolbarMenuButtonInstanceApi as ToolbarMenuButtonInstanceApi, PublicToolbar_d_ToolbarToggleButtonSpec as ToolbarToggleButtonSpec, PublicToolbar_d_ToolbarToggleButtonInstanceApi as ToolbarToggleButtonInstanceApi, PublicToolbar_d_GroupToolbarButtonSpec as GroupToolbarButtonSpec, PublicToolbar_d_GroupToolbarButtonInstanceApi as GroupToolbarButtonInstanceApi, };

}

declare namespace PublicToolbar_d {

export { PublicToolbar_d_ToolbarButtonSpec as ToolbarButtonSpec, PublicToolbar_d_ToolbarButtonInstanceApi as ToolbarButtonInstanceApi, PublicToolbar_d_ToolbarSplitButtonSpec as ToolbarSplitButtonSpec, PublicToolbar_d_ToolbarSplitButtonInstanceApi as ToolbarSplitButtonInstanceApi, PublicToolbar_d_ToolbarMenuButtonSpec as ToolbarMenuButtonSpec, PublicToolbar_d_ToolbarMenuButtonInstanceApi as ToolbarMenuButtonInstanceApi, PublicToolbar_d_ToolbarToggleButtonSpec as ToolbarToggleButtonSpec, PublicToolbar_d_ToolbarToggleButtonInstanceApi as ToolbarToggleButtonInstanceApi, PublicToolbar_d_GroupToolbarButtonSpec as GroupToolbarButtonSpec, PublicToolbar_d_GroupToolbarButtonInstanceApi as GroupToolbarButtonInstanceApi, };

}

+interface ViewButtonApi {

+ setIcon: (newIcon: string) => void;

+}

+interface ViewToggleButtonApi extends ViewButtonApi {

+ isActive: () => boolean;

+ setActive: (state: boolean) => void;

+}

+interface BaseButtonSpec<Api extends ViewButtonApi> {

+ text?: string;

+ icon?: string;

+ tooltip?: string;

+ buttonType?: 'primary' | 'secondary';

+ borderless?: boolean;

+ onAction: (api: Api) => void;

+}

+interface ViewNormalButtonSpec extends BaseButtonSpec<ViewButtonApi> {

+ text: string;

+ type: 'button';

+}

+interface ViewToggleButtonSpec extends BaseButtonSpec<ViewToggleButtonApi> {

+ type: 'togglebutton';

+ active?: boolean;

+ onAction: (api: ViewToggleButtonApi) => void;

+}

+interface ViewButtonsGroupSpec {

+ type: 'group';

+ buttons: Array<ViewNormalButtonSpec | ViewToggleButtonSpec>;

+}

+type ViewButtonSpec = ViewNormalButtonSpec | ViewToggleButtonSpec | ViewButtonsGroupSpec;

+interface ViewInstanceApi {

+ getContainer: () => HTMLElement;

+}

+interface ViewSpec {

+ buttons?: ViewButtonSpec[];

+ onShow: (api: ViewInstanceApi) => void;

+ onHide: (api: ViewInstanceApi) => void;

+}

+type PublicView_d_ViewSpec = ViewSpec;

+type PublicView_d_ViewInstanceApi = ViewInstanceApi;

+declare namespace PublicView_d {

+ export { PublicView_d_ViewSpec as ViewSpec, PublicView_d_ViewInstanceApi as ViewInstanceApi, };

+}

interface Registry$1 {

addButton: (name: string, spec: ToolbarButtonSpec) => void;

addGroupToolbarButton: (name: string, spec: GroupToolbarButtonSpec) => void;

interface Registry$1 {

addButton: (name: string, spec: ToolbarButtonSpec) => void;

addGroupToolbarButton: (name: string, spec: GroupToolbarButtonSpec) => void;

addIcon: (name: string, svgData: string) => void;

addAutocompleter: (name: string, spec: AutocompleterSpec) => void;

addSidebar: (name: string, spec: SidebarSpec) => void;

addIcon: (name: string, svgData: string) => void;

addAutocompleter: (name: string, spec: AutocompleterSpec) => void;

addSidebar: (name: string, spec: SidebarSpec) => void;

+ addView: (name: string, spec: ViewSpec) => void;

getAll: () => {

buttons: Record<string, ToolbarButtonSpec | GroupToolbarButtonSpec | ToolbarMenuButtonSpec | ToolbarSplitButtonSpec | ToolbarToggleButtonSpec>;

menuItems: Record<string, MenuItemSpec | NestedMenuItemSpec | ToggleMenuItemSpec>;

getAll: () => {

buttons: Record<string, ToolbarButtonSpec | GroupToolbarButtonSpec | ToolbarMenuButtonSpec | ToolbarSplitButtonSpec | ToolbarToggleButtonSpec>;

menuItems: Record<string, MenuItemSpec | NestedMenuItemSpec | ToggleMenuItemSpec>;

contextToolbars: Record<string, ContextToolbarSpec | ContextFormSpec>;

icons: Record<string, string>;

sidebars: Record<string, SidebarSpec>;

contextToolbars: Record<string, ContextToolbarSpec | ContextFormSpec>;

icons: Record<string, string>;

sidebars: Record<string, SidebarSpec>;

+ views: Record<string, ViewSpec>;

};

}

interface AutocompleteLookupData {

readonly matchText: string;

readonly items: AutocompleterContents[];

};

}

interface AutocompleteLookupData {

readonly matchText: string;

readonly items: AutocompleterContents[];

- readonly columns: ColumnTypes$1;

+ readonly columns: ColumnTypes;

readonly onAction: (autoApi: AutocompleterInstanceApi, rng: Range, value: string, meta: Record<string, any>) => void;

readonly highlightOn: string[];

}

readonly onAction: (autoApi: AutocompleterInstanceApi, rng: Range, value: string, meta: Record<string, any>) => void;

readonly highlightOn: string[];

}

endContainer: Node;

endOffset: number;

}

endContainer: Node;

endOffset: number;

}

-declare type ApplyFormat = BlockFormat | InlineFormat | SelectorFormat;

-declare type RemoveFormat = RemoveBlockFormat | RemoveInlineFormat | RemoveSelectorFormat;

-declare type Format = ApplyFormat | RemoveFormat;

-declare type Formats = Record<string, Format | Format[]>;

-declare type FormatAttrOrStyleValue = string | ((vars?: FormatVars) => string);

-declare type FormatVars = Record<string, string | null>;

+type ApplyFormat = BlockFormat | InlineFormat | SelectorFormat;

+type RemoveFormat = RemoveBlockFormat | RemoveInlineFormat | RemoveSelectorFormat;

+type Format = ApplyFormat | RemoveFormat;

+type Formats = Record<string, Format | Format[]>;

+type FormatAttrOrStyleValue = string | ((vars?: FormatVars) => string | null);

+type FormatVars = Record<string, string | null>;

interface BaseFormat<T> {

ceFalseOverride?: boolean;

classes?: string | string[];

interface BaseFormat<T> {

ceFalseOverride?: boolean;

classes?: string | string[];

links?: boolean;

mixed?: boolean;

block_expand?: boolean;

links?: boolean;

mixed?: boolean;

block_expand?: boolean;

- onmatch?: (node: Node, fmt: T, itemName: string) => boolean;

+ onmatch?: (node: Element, fmt: T, itemName: string) => boolean;

remove?: 'none' | 'empty' | 'all';

remove_similar?: boolean;

split?: boolean;

remove?: 'none' | 'empty' | 'all';

remove_similar?: boolean;

split?: boolean;

styles?: Record<string, FormatAttrOrStyleValue>;

toggle?: boolean;

preview?: string | false;

styles?: Record<string, FormatAttrOrStyleValue>;

toggle?: boolean;

preview?: string | false;

- onformat?: (elm: Node, fmt: T, vars?: FormatVars, node?: Node | RangeLikeObject) => void;

+ onformat?: (elm: Element, fmt: T, vars?: FormatVars, node?: Node | RangeLikeObject | null) => void;

clear_child_styles?: boolean;

merge_siblings?: boolean;

merge_with_parents?: boolean;

clear_child_styles?: boolean;

merge_siblings?: boolean;

merge_with_parents?: boolean;

no_events?: boolean;

[key: string]: any;

}

no_events?: boolean;

[key: string]: any;

}

-declare type ParserFilterCallback = (nodes: AstNode[], name: string, args: ParserArgs) => void;

+type ParserFilterCallback = (nodes: AstNode[], name: string, args: ParserArgs) => void;

interface ParserFilter extends Filter<ParserFilterCallback> {

}

interface DomParserSettings {

interface ParserFilter extends Filter<ParserFilterCallback> {

}

interface DomParserSettings {

allow_html_in_named_anchor?: boolean;

allow_script_urls?: boolean;

allow_unsafe_link_target?: boolean;

allow_html_in_named_anchor?: boolean;

allow_script_urls?: boolean;

allow_unsafe_link_target?: boolean;

+ blob_cache?: BlobCache;

convert_fonts_to_spans?: boolean;

+ convert_unsafe_embeds?: boolean;

+ document?: Document;

fix_list_elements?: boolean;

font_size_legacy_values?: string;

forced_root_block?: boolean | string;

forced_root_block_attrs?: Record<string, string>;

fix_list_elements?: boolean;

font_size_legacy_values?: string;

forced_root_block?: boolean | string;

forced_root_block_attrs?: Record<string, string>;

+ inline_styles?: boolean;

+ pad_empty_with_br?: boolean;

preserve_cdata?: boolean;

remove_trailing_brs?: boolean;

root_name?: string;

preserve_cdata?: boolean;

remove_trailing_brs?: boolean;

root_name?: string;

+ sandbox_iframes?: boolean;

+ sanitize?: boolean;

validate?: boolean;

- inline_styles?: boolean;

- blob_cache?: BlobCache;

- document?: Document;

}

interface DomParser {

schema: Schema;

}

interface DomParser {

schema: Schema;

}

interface StyleSheetLoader {

load: (url: string) => Promise<void>;

}

interface StyleSheetLoader {

load: (url: string) => Promise<void>;

+ loadRawCss: (key: string, css: string) => void;

loadAll: (urls: string[]) => Promise<string[]>;

unload: (url: string) => void;

loadAll: (urls: string[]) => Promise<string[]>;

unload: (url: string) => void;

+ unloadRawCss: (key: string) => void;

unloadAll: (urls: string[]) => void;

_setReferrerPolicy: (referrerPolicy: ReferrerPolicy) => void;

unloadAll: (urls: string[]) => void;

_setReferrerPolicy: (referrerPolicy: ReferrerPolicy) => void;

+ _setContentCssCors: (contentCssCors: boolean) => void;

}

-declare type Registry = Registry$1;

+type Registry = Registry$1;

interface EditorUiApi {

show: () => void;

hide: () => void;

interface EditorUiApi {

show: () => void;

hide: () => void;

type Ui_d_EditorUiApi = EditorUiApi;

type Ui_d_EditorUi = EditorUi;

declare namespace Ui_d {

type Ui_d_EditorUiApi = EditorUiApi;

type Ui_d_EditorUi = EditorUi;

declare namespace Ui_d {

- export { Ui_d_Registry as Registry, PublicDialog_d as Dialog, PublicInlineContent_d as InlineContent, PublicMenu_d as Menu, PublicSidebar_d as Sidebar, PublicToolbar_d as Toolbar, Ui_d_EditorUiApi as EditorUiApi, Ui_d_EditorUi as EditorUi, };

+ export { Ui_d_Registry as Registry, PublicDialog_d as Dialog, PublicInlineContent_d as InlineContent, PublicMenu_d as Menu, PublicView_d as View, PublicSidebar_d as Sidebar, PublicToolbar_d as Toolbar, Ui_d_EditorUiApi as EditorUiApi, Ui_d_EditorUi as EditorUi, };

}

interface WindowParams {

}

interface WindowParams {

- readonly inline?: 'cursor' | 'toolbar';

+ readonly inline?: 'cursor' | 'toolbar' | 'bottom';

readonly ariaAttrs?: boolean;

+ readonly persistent?: boolean;

}

-declare type InstanceApi<T> = UrlDialogInstanceApi | DialogInstanceApi<T>;

+type InstanceApi<T extends DialogData> = UrlDialogInstanceApi | DialogInstanceApi<T>;

interface WindowManagerImpl {

- open: <T>(config: DialogSpec<T>, params: WindowParams, closeWindow: (dialog: DialogInstanceApi<T>) => void) => DialogInstanceApi<T>;

+ open: <T extends DialogData>(config: DialogSpec<T>, params: WindowParams | undefined, closeWindow: (dialog: DialogInstanceApi<T>) => void) => DialogInstanceApi<T>;

openUrl: (config: UrlDialogSpec, closeWindow: (dialog: UrlDialogInstanceApi) => void) => UrlDialogInstanceApi;

alert: (message: string, callback: () => void) => void;

confirm: (message: string, callback: (state: boolean) => void) => void;

close: (dialog: InstanceApi<any>) => void;

}

interface WindowManager {

openUrl: (config: UrlDialogSpec, closeWindow: (dialog: UrlDialogInstanceApi) => void) => UrlDialogInstanceApi;

alert: (message: string, callback: () => void) => void;

confirm: (message: string, callback: (state: boolean) => void) => void;

close: (dialog: InstanceApi<any>) => void;

}

interface WindowManager {

- open: <T>(config: DialogSpec<T>, params?: WindowParams) => DialogInstanceApi<T>;

+ open: <T extends DialogData>(config: DialogSpec<T>, params?: WindowParams) => DialogInstanceApi<T>;

openUrl: (config: UrlDialogSpec) => UrlDialogInstanceApi;

alert: (message: string, callback?: () => void, scope?: any) => void;

confirm: (message: string, callback?: (state: boolean) => void, scope?: any) => void;

openUrl: (config: UrlDialogSpec) => UrlDialogInstanceApi;

alert: (message: string, callback?: () => void, scope?: any) => void;

confirm: (message: string, callback?: (state: boolean) => void, scope?: any) => void;

}

interface ExecCommandEvent {

command: string;

}

interface ExecCommandEvent {

command: string;

- ui?: boolean;

+ ui: boolean;

value?: any;

}

interface BeforeGetContentEvent extends GetContentArgs {

value?: any;

}

interface BeforeGetContentEvent extends GetContentArgs {

interface SetContentEvent extends BeforeSetContentEvent {

content: string;

}

interface SetContentEvent extends BeforeSetContentEvent {

content: string;

}

+interface SaveContentEvent extends GetContentEvent {

+ save: boolean;

+}

interface NewBlockEvent {

newBlock: Element;

}

interface NewBlockEvent {

newBlock: Element;

}

interface FormatEvent {

format: string;

vars?: FormatVars;

interface FormatEvent {

format: string;

vars?: FormatVars;

- node?: Node | RangeLikeObject;

+ node?: Node | RangeLikeObject | null;

}

interface ObjectResizeEvent {

target: HTMLElement;

}

interface ObjectResizeEvent {

target: HTMLElement;

}

interface ScrollIntoViewEvent {

elm: HTMLElement;

}

interface ScrollIntoViewEvent {

elm: HTMLElement;

- alignToTop: boolean;

+ alignToTop: boolean | undefined;

}

interface SetSelectionRangeEvent {

range: Range;

}

interface SetSelectionRangeEvent {

range: Range;

- forward: boolean;

+ forward: boolean | undefined;

}

interface ShowCaretEvent {

target: Node;

}

interface ShowCaretEvent {

target: Node;

interface SwitchModeEvent {

mode: string;

}

interface SwitchModeEvent {

mode: string;

}

-interface AddUndoEvent {

+interface ChangeEvent {

level: UndoLevel;

- lastLevel: UndoLevel;

- originalEvent: Event;

+ lastLevel: UndoLevel | undefined;

+}

+interface AddUndoEvent extends ChangeEvent {

+ originalEvent: Event | undefined;

}

interface UndoRedoEvent {

level: UndoLevel;

}

interface UndoRedoEvent {

level: UndoLevel;

node: HTMLElement;

readonly internal: boolean;

}

node: HTMLElement;

readonly internal: boolean;

}

+interface EditableRootStateChangeEvent {

+ state: boolean;

+}

interface NewTableRowEvent {

node: HTMLTableRowElement;

}

interface NewTableRowEvent {

node: HTMLTableRowElement;

}

interface TableModifiedEvent extends TableEventData {

readonly table: HTMLTableElement;

}

interface TableModifiedEvent extends TableEventData {

readonly table: HTMLTableElement;

}

+interface BeforeOpenNotificationEvent {

+ notification: NotificationSpec;

+}

+interface OpenNotificationEvent {

+ notification: NotificationApi;

+}

interface EditorEventMap extends Omit<NativeEventMap, 'blur' | 'focus'> {

'activate': {

interface EditorEventMap extends Omit<NativeEventMap, 'blur' | 'focus'> {

'activate': {

- relatedTarget: Editor;

+ relatedTarget: Editor | null;

};

'deactivate': {

relatedTarget: Editor;

};

'focus': {

};

'deactivate': {

relatedTarget: Editor;

};

'focus': {

- blurredEditor: Editor;

+ blurredEditor: Editor | null;

};

'blur': {

};

'blur': {

- focusedEditor: Editor;

+ focusedEditor: Editor | null;

};

'resize': UIEvent;

'scroll': UIEvent;

};

'resize': UIEvent;

'scroll': UIEvent;

+ 'input': InputEvent;

+ 'beforeinput': InputEvent;

'detach': {};

'remove': {};

'init': {};

'detach': {};

'remove': {};

'init': {};

'ObjectResized': ObjectResizeEvent;

'ObjectResizeStart': ObjectResizeEvent;

'SwitchMode': SwitchModeEvent;

'ObjectResized': ObjectResizeEvent;

'ObjectResizeStart': ObjectResizeEvent;

'SwitchMode': SwitchModeEvent;

- 'ScrollWindow': UIEvent;

+ 'ScrollWindow': Event;

'ResizeWindow': UIEvent;

'SkinLoaded': {};

'SkinLoadError': LoadErrorEvent;

'ResizeWindow': UIEvent;

'SkinLoaded': {};

'SkinLoadError': LoadErrorEvent;

'GetContent': GetContentEvent;

'BeforeSetContent': BeforeSetContentEvent;

'SetContent': SetContentEvent;

'GetContent': GetContentEvent;

'BeforeSetContent': BeforeSetContentEvent;

'SetContent': SetContentEvent;

- 'LoadContent': {};

+ 'SaveContent': SaveContentEvent;

+ 'RawSaveContent': SaveContentEvent;

+ 'LoadContent': {

+ load: boolean;

+ element: HTMLElement;

+ };

'PreviewFormats': {};

'AfterPreviewFormats': {};

'ScriptsLoaded': {};

'PreviewFormats': {};

'AfterPreviewFormats': {};

'ScriptsLoaded': {};

'Undo': UndoRedoEvent;

'BeforeAddUndo': AddUndoEvent;

'AddUndo': AddUndoEvent;

'Undo': UndoRedoEvent;

'BeforeAddUndo': AddUndoEvent;

'AddUndo': AddUndoEvent;

+ 'change': ChangeEvent;

'CloseWindow': WindowEvent<any>;

'OpenWindow': WindowEvent<any>;

'ProgressState': ProgressStateEvent;

'CloseWindow': WindowEvent<any>;

'OpenWindow': WindowEvent<any>;

'ProgressState': ProgressStateEvent;

'TableModified': TableModifiedEvent;

'NewRow': NewTableRowEvent;

'NewCell': NewTableCellEvent;

'TableModified': TableModifiedEvent;

'NewRow': NewTableRowEvent;

'NewCell': NewTableCellEvent;

+ 'SetAttrib': SetAttribEvent;

+ 'hide': {};

+ 'show': {};

+ 'dirty': {};

+ 'BeforeOpenNotification': BeforeOpenNotificationEvent;

+ 'OpenNotification': OpenNotificationEvent;

}

interface EditorManagerEventMap {

'AddEditor': {

}

interface EditorManagerEventMap {

'AddEditor': {

type EventTypes_d_GetContentEvent = GetContentEvent;

type EventTypes_d_BeforeSetContentEvent = BeforeSetContentEvent;

type EventTypes_d_SetContentEvent = SetContentEvent;

type EventTypes_d_GetContentEvent = GetContentEvent;

type EventTypes_d_BeforeSetContentEvent = BeforeSetContentEvent;

type EventTypes_d_SetContentEvent = SetContentEvent;

+type EventTypes_d_SaveContentEvent = SaveContentEvent;

type EventTypes_d_NewBlockEvent = NewBlockEvent;

type EventTypes_d_NodeChangeEvent = NodeChangeEvent;

type EventTypes_d_FormatEvent = FormatEvent;

type EventTypes_d_NewBlockEvent = NewBlockEvent;

type EventTypes_d_NodeChangeEvent = NodeChangeEvent;

type EventTypes_d_FormatEvent = FormatEvent;

type EventTypes_d_SetSelectionRangeEvent = SetSelectionRangeEvent;

type EventTypes_d_ShowCaretEvent = ShowCaretEvent;

type EventTypes_d_SwitchModeEvent = SwitchModeEvent;

type EventTypes_d_SetSelectionRangeEvent = SetSelectionRangeEvent;

type EventTypes_d_ShowCaretEvent = ShowCaretEvent;

type EventTypes_d_SwitchModeEvent = SwitchModeEvent;

+type EventTypes_d_ChangeEvent = ChangeEvent;

type EventTypes_d_AddUndoEvent = AddUndoEvent;

type EventTypes_d_UndoRedoEvent = UndoRedoEvent;

type EventTypes_d_AddUndoEvent = AddUndoEvent;

type EventTypes_d_UndoRedoEvent = UndoRedoEvent;

-type EventTypes_d_WindowEvent<_0> = WindowEvent<_0>;

+type EventTypes_d_WindowEvent<T extends DialogData> = WindowEvent<T>;

type EventTypes_d_ProgressStateEvent = ProgressStateEvent;

type EventTypes_d_AfterProgressStateEvent = AfterProgressStateEvent;

type EventTypes_d_PlaceholderToggleEvent = PlaceholderToggleEvent;

type EventTypes_d_ProgressStateEvent = ProgressStateEvent;

type EventTypes_d_AfterProgressStateEvent = AfterProgressStateEvent;

type EventTypes_d_PlaceholderToggleEvent = PlaceholderToggleEvent;

type EventTypes_d_PastePlainTextToggleEvent = PastePlainTextToggleEvent;

type EventTypes_d_PastePreProcessEvent = PastePreProcessEvent;

type EventTypes_d_PastePostProcessEvent = PastePostProcessEvent;

type EventTypes_d_PastePlainTextToggleEvent = PastePlainTextToggleEvent;

type EventTypes_d_PastePreProcessEvent = PastePreProcessEvent;

type EventTypes_d_PastePostProcessEvent = PastePostProcessEvent;

+type EventTypes_d_EditableRootStateChangeEvent = EditableRootStateChangeEvent;

type EventTypes_d_NewTableRowEvent = NewTableRowEvent;

type EventTypes_d_NewTableCellEvent = NewTableCellEvent;

type EventTypes_d_TableEventData = TableEventData;

type EventTypes_d_TableModifiedEvent = TableModifiedEvent;

type EventTypes_d_NewTableRowEvent = NewTableRowEvent;

type EventTypes_d_NewTableCellEvent = NewTableCellEvent;

type EventTypes_d_TableEventData = TableEventData;

type EventTypes_d_TableModifiedEvent = TableModifiedEvent;

+type EventTypes_d_BeforeOpenNotificationEvent = BeforeOpenNotificationEvent;

+type EventTypes_d_OpenNotificationEvent = OpenNotificationEvent;

type EventTypes_d_EditorEventMap = EditorEventMap;

type EventTypes_d_EditorManagerEventMap = EditorManagerEventMap;

declare namespace EventTypes_d {

type EventTypes_d_EditorEventMap = EditorEventMap;

type EventTypes_d_EditorManagerEventMap = EditorManagerEventMap;

declare namespace EventTypes_d {

- export { EventTypes_d_ExecCommandEvent as ExecCommandEvent, EventTypes_d_BeforeGetContentEvent as BeforeGetContentEvent, EventTypes_d_GetContentEvent as GetContentEvent, EventTypes_d_BeforeSetContentEvent as BeforeSetContentEvent, EventTypes_d_SetContentEvent as SetContentEvent, EventTypes_d_NewBlockEvent as NewBlockEvent, EventTypes_d_NodeChangeEvent as NodeChangeEvent, EventTypes_d_FormatEvent as FormatEvent, EventTypes_d_ObjectResizeEvent as ObjectResizeEvent, EventTypes_d_ObjectSelectedEvent as ObjectSelectedEvent, EventTypes_d_ScrollIntoViewEvent as ScrollIntoViewEvent, EventTypes_d_SetSelectionRangeEvent as SetSelectionRangeEvent, EventTypes_d_ShowCaretEvent as ShowCaretEvent, EventTypes_d_SwitchModeEvent as SwitchModeEvent, EventTypes_d_AddUndoEvent as AddUndoEvent, EventTypes_d_UndoRedoEvent as UndoRedoEvent, EventTypes_d_WindowEvent as WindowEvent, EventTypes_d_ProgressStateEvent as ProgressStateEvent, EventTypes_d_AfterProgressStateEvent as AfterProgressStateEvent, EventTypes_d_PlaceholderToggleEvent as PlaceholderToggleEvent, EventTypes_d_LoadErrorEvent as LoadErrorEvent, EventTypes_d_PreProcessEvent as PreProcessEvent, EventTypes_d_PostProcessEvent as PostProcessEvent, EventTypes_d_PastePlainTextToggleEvent as PastePlainTextToggleEvent, EventTypes_d_PastePreProcessEvent as PastePreProcessEvent, EventTypes_d_PastePostProcessEvent as PastePostProcessEvent, EventTypes_d_NewTableRowEvent as NewTableRowEvent, EventTypes_d_NewTableCellEvent as NewTableCellEvent, EventTypes_d_TableEventData as TableEventData, EventTypes_d_TableModifiedEvent as TableModifiedEvent, EventTypes_d_EditorEventMap as EditorEventMap, EventTypes_d_EditorManagerEventMap as EditorManagerEventMap, };

+ export { EventTypes_d_ExecCommandEvent as ExecCommandEvent, EventTypes_d_BeforeGetContentEvent as BeforeGetContentEvent, EventTypes_d_GetContentEvent as GetContentEvent, EventTypes_d_BeforeSetContentEvent as BeforeSetContentEvent, EventTypes_d_SetContentEvent as SetContentEvent, EventTypes_d_SaveContentEvent as SaveContentEvent, EventTypes_d_NewBlockEvent as NewBlockEvent, EventTypes_d_NodeChangeEvent as NodeChangeEvent, EventTypes_d_FormatEvent as FormatEvent, EventTypes_d_ObjectResizeEvent as ObjectResizeEvent, EventTypes_d_ObjectSelectedEvent as ObjectSelectedEvent, EventTypes_d_ScrollIntoViewEvent as ScrollIntoViewEvent, EventTypes_d_SetSelectionRangeEvent as SetSelectionRangeEvent, EventTypes_d_ShowCaretEvent as ShowCaretEvent, EventTypes_d_SwitchModeEvent as SwitchModeEvent, EventTypes_d_ChangeEvent as ChangeEvent, EventTypes_d_AddUndoEvent as AddUndoEvent, EventTypes_d_UndoRedoEvent as UndoRedoEvent, EventTypes_d_WindowEvent as WindowEvent, EventTypes_d_ProgressStateEvent as ProgressStateEvent, EventTypes_d_AfterProgressStateEvent as AfterProgressStateEvent, EventTypes_d_PlaceholderToggleEvent as PlaceholderToggleEvent, EventTypes_d_LoadErrorEvent as LoadErrorEvent, EventTypes_d_PreProcessEvent as PreProcessEvent, EventTypes_d_PostProcessEvent as PostProcessEvent, EventTypes_d_PastePlainTextToggleEvent as PastePlainTextToggleEvent, EventTypes_d_PastePreProcessEvent as PastePreProcessEvent, EventTypes_d_PastePostProcessEvent as PastePostProcessEvent, EventTypes_d_EditableRootStateChangeEvent as EditableRootStateChangeEvent, EventTypes_d_NewTableRowEvent as NewTableRowEvent, EventTypes_d_NewTableCellEvent as NewTableCellEvent, EventTypes_d_TableEventData as TableEventData, EventTypes_d_TableModifiedEvent as TableModifiedEvent, EventTypes_d_BeforeOpenNotificationEvent as BeforeOpenNotificationEvent, EventTypes_d_OpenNotificationEvent as OpenNotificationEvent, EventTypes_d_EditorEventMap as EditorEventMap, EventTypes_d_EditorManagerEventMap as EditorManagerEventMap, };

}

type Format_d_Formats = Formats;

type Format_d_Format = Format;

}

type Format_d_Formats = Formats;

type Format_d_Format = Format;

declare namespace Format_d {

export { Format_d_Formats as Formats, Format_d_Format as Format, Format_d_ApplyFormat as ApplyFormat, Format_d_BlockFormat as BlockFormat, Format_d_InlineFormat as InlineFormat, Format_d_SelectorFormat as SelectorFormat, Format_d_RemoveFormat as RemoveFormat, Format_d_RemoveBlockFormat as RemoveBlockFormat, Format_d_RemoveInlineFormat as RemoveInlineFormat, Format_d_RemoveSelectorFormat as RemoveSelectorFormat, };

}

declare namespace Format_d {

export { Format_d_Formats as Formats, Format_d_Format as Format, Format_d_ApplyFormat as ApplyFormat, Format_d_BlockFormat as BlockFormat, Format_d_InlineFormat as InlineFormat, Format_d_SelectorFormat as SelectorFormat, Format_d_RemoveFormat as RemoveFormat, Format_d_RemoveBlockFormat as RemoveBlockFormat, Format_d_RemoveInlineFormat as RemoveInlineFormat, Format_d_RemoveSelectorFormat as RemoveSelectorFormat, };

}

-declare type StyleFormat = BlockStyleFormat | InlineStyleFormat | SelectorStyleFormat;

-declare type AllowedFormat = Separator | FormatReference | StyleFormat | NestedFormatting;

+type StyleFormat = BlockStyleFormat | InlineStyleFormat | SelectorStyleFormat;

+type AllowedFormat = Separator | FormatReference | StyleFormat | NestedFormatting;

interface Separator {

title: string;

}

interface Separator {

title: string;

}

interface SelectorStyleFormat extends SelectorFormat, CommonStyleFormat {

}

interface SelectorStyleFormat extends SelectorFormat, CommonStyleFormat {

}

interface ContentLanguage {

readonly title: string;

readonly code: string;

readonly customCode?: string;

}

interface ContentLanguage {

readonly title: string;

readonly code: string;

readonly customCode?: string;

}

-declare type ThemeInitFunc = (editor: Editor, elm: HTMLElement) => {

+type ThemeInitFunc = (editor: Editor, elm: HTMLElement) => {

editorContainer: HTMLElement;

iframeContainer: HTMLElement;

height?: number;

iframeHeight?: number;

api?: EditorUiApi;

};

editorContainer: HTMLElement;

iframeContainer: HTMLElement;

height?: number;

iframeHeight?: number;

api?: EditorUiApi;

};

-declare type SetupCallback = (editor: Editor) => void;

-declare type FilePickerCallback = (callback: Function, value: any, meta: Record<string, any>) => void;

-declare type FilePickerValidationStatus = 'valid' | 'unknown' | 'invalid' | 'none';

-declare type FilePickerValidationCallback = (info: {

+type SetupCallback = (editor: Editor) => void;

+type FilePickerCallback = (callback: (value: string, meta?: Record<string, any>) => void, value: string, meta: Record<string, any>) => void;

+type FilePickerValidationStatus = 'valid' | 'unknown' | 'invalid' | 'none';

+type FilePickerValidationCallback = (info: {

type: string;

url: string;

}, callback: (validation: {

status: FilePickerValidationStatus;

message: string;

}) => void) => void;

type: string;

url: string;

}, callback: (validation: {

status: FilePickerValidationStatus;

message: string;

}) => void) => void;

-declare type PastePreProcessFn = (editor: Editor, args: PastePreProcessEvent) => void;

-declare type PastePostProcessFn = (editor: Editor, args: PastePostProcessEvent) => void;

-declare type URLConverter = (url: string, name: string, elm?: HTMLElement) => string;

-declare type URLConverterCallback = (url: string, node: Node, on_save: boolean, name: string) => string;

+type PastePreProcessFn = (editor: Editor, args: PastePreProcessEvent) => void;

+type PastePostProcessFn = (editor: Editor, args: PastePostProcessEvent) => void;

+type URLConverter = (url: string, name: string, elm?: string | Element) => string;

+type URLConverterCallback = (url: string, node: Node | string | undefined, on_save: boolean, name: string) => string;

interface ToolbarGroup {

name?: string;

items: string[];

}

interface ToolbarGroup {

name?: string;

items: string[];

}

-declare type ToolbarMode = 'floating' | 'sliding' | 'scrolling' | 'wrap';

+type ToolbarMode = 'floating' | 'sliding' | 'scrolling' | 'wrap';

+type ToolbarLocation = 'top' | 'bottom' | 'auto';

+type ForceHexColor = 'always' | 'rgb_only' | 'off';

interface BaseEditorOptions {

a11y_advanced_options?: boolean;

add_form_submit_trigger?: boolean;

interface BaseEditorOptions {

a11y_advanced_options?: boolean;

add_form_submit_trigger?: boolean;

branding?: boolean;

cache_suffix?: string;

color_cols?: number;

branding?: boolean;

cache_suffix?: string;

color_cols?: number;

+ color_cols_foreground?: number;

+ color_cols_background?: number;

color_map?: string[];

+ color_map_foreground?: string[];

+ color_map_background?: string[];

+ color_default_foreground?: string;

+ color_default_background?: string;

content_css?: boolean | string | string[];

content_css_cors?: boolean;

content_security_policy?: string;

content_css?: boolean | string | string[];

content_css_cors?: boolean;

content_security_policy?: string;

contextmenu?: string | string[] | false;

contextmenu_never_use_native?: boolean;

convert_fonts_to_spans?: boolean;

contextmenu?: string | string[] | false;

contextmenu_never_use_native?: boolean;

convert_fonts_to_spans?: boolean;

+ convert_unsafe_embeds?: boolean;

convert_urls?: boolean;

custom_colors?: boolean;

custom_elements?: string;

custom_ui_selector?: string;

custom_undo_redo_levels?: number;

convert_urls?: boolean;

custom_colors?: boolean;

custom_elements?: string;

custom_ui_selector?: string;

custom_undo_redo_levels?: number;

+ default_font_stack?: string[];

deprecation_warnings?: boolean;

directionality?: 'ltr' | 'rtl';

doctype?: string;

document_base_url?: string;

deprecation_warnings?: boolean;

directionality?: 'ltr' | 'rtl';

doctype?: string;

document_base_url?: string;

+ draggable_modal?: boolean;

editable_class?: string;

+ editable_root?: boolean;

element_format?: 'xhtml' | 'html';

elementpath?: boolean;

encoding?: string;

element_format?: 'xhtml' | 'html';

elementpath?: boolean;

encoding?: string;

font_size_legacy_values?: string;

font_size_style_values?: string;

font_size_formats?: string;

font_size_legacy_values?: string;

font_size_style_values?: string;

font_size_formats?: string;

+ font_size_input_default_unit?: string;

+ force_hex_color?: ForceHexColor;

forced_root_block?: string;

forced_root_block_attrs?: Record<string, string>;

formats?: Formats;

forced_root_block?: string;

forced_root_block_attrs?: Record<string, string>;

formats?: Formats;

+ format_noneditable_selector?: string;

height?: number | string;

+ help_accessibility?: boolean;

hidden_input?: boolean;

+ highlight_on_focus?: boolean;

icons?: string;

icons_url?: string;

id?: string;

icons?: string;

icons_url?: string;

id?: string;

min_width?: number;

model?: string;

model_url?: string;

min_width?: number;

model?: string;

model_url?: string;

+ newdocument_content?: string;

newline_behavior?: 'block' | 'linebreak' | 'invert' | 'default';

no_newline_selector?: string;

noneditable_class?: string;

noneditable_regexp?: RegExp | RegExp[];

nowrap?: boolean;

object_resizing?: boolean | string;

newline_behavior?: 'block' | 'linebreak' | 'invert' | 'default';

no_newline_selector?: string;

noneditable_class?: string;

noneditable_regexp?: RegExp | RegExp[];

nowrap?: boolean;

object_resizing?: boolean | string;

+ pad_empty_with_br?: boolean;

paste_as_text?: boolean;

paste_block_drop?: boolean;

paste_data_images?: boolean;

paste_as_text?: boolean;

paste_block_drop?: boolean;

paste_data_images?: boolean;

placeholder?: string;

preserve_cdata?: boolean;

preview_styles?: false | string;

placeholder?: string;

preserve_cdata?: boolean;

preview_styles?: false | string;

+ promotion?: boolean;

protect?: RegExp[];

readonly?: boolean;

referrer_policy?: ReferrerPolicy;

protect?: RegExp[];

readonly?: boolean;

referrer_policy?: ReferrerPolicy;

resize?: boolean | 'both';

resize_img_proportional?: boolean;

root_name?: string;

resize?: boolean | 'both';

resize_img_proportional?: boolean;

root_name?: string;

+ sandbox_iframes?: boolean;

schema?: SchemaType;

selector?: string;

setup?: SetupCallback;

schema?: SchemaType;

selector?: string;

setup?: SetupCallback;

table_tab_navigation?: boolean;

target?: HTMLElement;

text_patterns?: RawPattern[] | false;

table_tab_navigation?: boolean;

target?: HTMLElement;

text_patterns?: RawPattern[] | false;

+ text_patterns_lookup?: RawDynamicPatternsLookup;

theme?: string | ThemeInitFunc | false;

theme_url?: string;

toolbar?: boolean | string | string[] | Array<ToolbarGroup>;

theme?: string | ThemeInitFunc | false;

theme_url?: string;

toolbar?: boolean | string | string[] | Array<ToolbarGroup>;

toolbar7?: string;

toolbar8?: string;

toolbar9?: string;

toolbar7?: string;

toolbar8?: string;

toolbar9?: string;

+ toolbar_groups?: Record<string, GroupToolbarButtonSpec>;

+ toolbar_location?: ToolbarLocation;

toolbar_mode?: ToolbarMode;

toolbar_sticky?: boolean;

toolbar_sticky_offset?: number;

typeahead_urls?: boolean;

toolbar_mode?: ToolbarMode;

toolbar_sticky?: boolean;

toolbar_sticky_offset?: number;

typeahead_urls?: boolean;

+ ui_mode?: 'combined' | 'split';

url_converter?: URLConverter;

url_converter_scope?: any;

urlconverter_callback?: URLConverterCallback;

url_converter?: URLConverter;

url_converter_scope?: any;

urlconverter_callback?: URLConverterCallback;

visual_anchor_class?: string;

visual_table_class?: string;

width?: number | string;

visual_anchor_class?: string;

visual_table_class?: string;

width?: number | string;

+ xss_sanitization?: boolean;

disable_nodechange?: boolean;

forced_plugins?: string | string[];

plugin_base_urls?: Record<string, string>;

disable_nodechange?: boolean;

forced_plugins?: string | string[];

plugin_base_urls?: Record<string, string>;

plugins: string[];

}

interface EditorOptions extends NormalizedEditorOptions {

plugins: string[];

}

interface EditorOptions extends NormalizedEditorOptions {

+ a11y_advanced_options: boolean;

+ allow_unsafe_link_target: boolean;

+ anchor_bottom: string;

+ anchor_top: string;

+ automatic_uploads: boolean;

+ block_formats: string;

+ body_class: string;

+ body_id: string;

+ br_newline_selector: string;

+ color_map: string[];

+ color_cols: number;

+ color_cols_foreground: number;

+ color_cols_background: number;

+ color_default_background: string;

+ color_default_foreground: string;

content_css: string[];

contextmenu: string[];

content_css: string[];

contextmenu: string[];

+ convert_unsafe_embeds: boolean;

+ custom_colors: boolean;

+ default_font_stack: string[];

+ document_base_url: string;

+ init_content_sync: boolean;

+ draggable_modal: boolean;

+ editable_class: string;

+ editable_root: boolean;

font_css: string[];

+ font_family_formats: string;

+ font_size_classes: string;

+ font_size_formats: string;

+ font_size_input_default_unit: string;

+ font_size_legacy_values: string;

+ font_size_style_values: string;

forced_root_block: string;

forced_root_block_attrs: Record<string, string>;

forced_root_block: string;

forced_root_block_attrs: Record<string, string>;

+ force_hex_color: ForceHexColor;

+ format_noneditable_selector: string;

+ height: number | string;

+ highlight_on_focus: boolean;

+ iframe_attrs: Record<string, string>;

+ images_file_types: string;

+ images_upload_base_path: string;

+ images_upload_credentials: boolean;

+ images_upload_url: string;

+ indent_use_margin: boolean;

+ indentation: string;

+ inline: boolean;

+ inline_boundaries_selector: string;

+ language: string;

+ language_load: boolean;

+ language_url: string;

+ line_height_formats: string;

+ menu: Record<string, {

+ title: string;

+ items: string;

+ }>;

+ menubar: boolean | string;

+ model: string;

+ newdocument_content: string;

+ no_newline_selector: string;

+ noneditable_class: string;

noneditable_regexp: RegExp[];

- object_resizing?: string;

- preview_styles?: string;

- text_patterns?: Pattern[];

-}

-declare type StyleMap = Record<string, string | number>;

+ object_resizing: string;

+ pad_empty_with_br: boolean;

+ paste_as_text: boolean;

+ preview_styles: string;

+ promotion: boolean;

+ readonly: boolean;

+ removed_menuitems: string;

+ sandbox_iframes: boolean;

+ toolbar: boolean | string | string[] | Array<ToolbarGroup>;

+ toolbar_groups: Record<string, GroupToolbarButtonSpec>;

+ toolbar_location: ToolbarLocation;

+ toolbar_mode: ToolbarMode;

+ toolbar_persist: boolean;

+ toolbar_sticky: boolean;

+ toolbar_sticky_offset: number;

+ text_patterns: Pattern[];

+ text_patterns_lookup: DynamicPatternsLookup;

+ visual: boolean;

+ visual_anchor_class: string;

+ visual_table_class: string;

+ width: number | string;

+ xss_sanitization: boolean;

+}

+type StyleMap = Record<string, string | number>;

interface StylesSettings {

allow_script_urls?: boolean;

allow_svg_data_urls?: boolean;

url_converter?: URLConverter;

url_converter_scope?: any;

interface StylesSettings {

allow_script_urls?: boolean;

allow_svg_data_urls?: boolean;

url_converter?: URLConverter;

url_converter_scope?: any;

+ force_hex_color?: ForceHexColor;

}

interface Styles {

}

interface Styles {

- parse: (css: string) => Record<string, string>;

+ parse: (css: string | undefined) => Record<string, string>;

serialize: (styles: StyleMap, elementName?: string) => string;

}

serialize: (styles: StyleMap, elementName?: string) => string;

}

-declare type EventUtilsCallback<T> = (event: EventUtilsEvent<T>) => void;

-declare type EventUtilsEvent<T> = NormalizedEvent<T> & {

+type EventUtilsCallback<T> = (event: EventUtilsEvent<T>) => void | boolean;

+type EventUtilsEvent<T> = NormalizedEvent<T> & {

metaKey: boolean;

};

metaKey: boolean;

};

+interface Callback$1<T> {

+ func: EventUtilsCallback<T>;

+ scope: any;

+}

+interface CallbackList<T> extends Array<Callback$1<T>> {

+ fakeName: string | false;

+ capture: boolean;

+ nativeHandler: EventListener;

+}

interface EventUtilsConstructor {

readonly prototype: EventUtils;

new (): EventUtils;

interface EventUtilsConstructor {

readonly prototype: EventUtils;

new (): EventUtils;

declare class EventUtils {

static Event: EventUtils;

domLoaded: boolean;

declare class EventUtils {

static Event: EventUtils;

domLoaded: boolean;

- events: Record<string, any>;

+ events: Record<number, Record<string, CallbackList<any>>>;

private readonly expando;

private hasFocusIn;

private readonly expando;

private hasFocusIn;

- private hasMouseEnterLeave;

- private mouseEnterLeave;

private count;

constructor();

bind<K extends keyof HTMLElementEventMap>(target: any, name: K, callback: EventUtilsCallback<HTMLElementEventMap[K]>, scope?: any): EventUtilsCallback<HTMLElementEventMap[K]>;

private count;

constructor();

bind<K extends keyof HTMLElementEventMap>(target: any, name: K, callback: EventUtilsCallback<HTMLElementEventMap[K]>, scope?: any): EventUtilsCallback<HTMLElementEventMap[K]>;

dispatch(target: any, name: string, args?: {}): this;

clean(target: any): this;

destroy(): void;

dispatch(target: any, name: string, args?: {}): this;

clean(target: any): this;

destroy(): void;

- cancel<T = any>(e: EventUtilsEvent<T>): boolean;

+ cancel<T>(e: EventUtilsEvent<T>): boolean;

private executeHandlers;

}

private executeHandlers;

}

+interface SetAttribEvent {

+ attrElm: HTMLElement;

+ attrName: string;

+ attrValue: string | boolean | number | null;

+}

interface DOMUtilsSettings {

schema: Schema;

url_converter: URLConverter;

interface DOMUtilsSettings {

schema: Schema;

url_converter: URLConverter;

ownEvents: boolean;

keep_values: boolean;

update_styles: boolean;

ownEvents: boolean;

keep_values: boolean;

update_styles: boolean;

- root_element: HTMLElement;

- collect: Function;

- onSetAttrib: Function;

+ root_element: HTMLElement | null;

+ collect: boolean;

+ onSetAttrib: (event: SetAttribEvent) => void;

contentCssCors: boolean;

referrerPolicy: ReferrerPolicy;

contentCssCors: boolean;

referrerPolicy: ReferrerPolicy;

+ force_hex_color: ForceHexColor;

}

-declare type Target = Node | Window;

-declare type RunArguments<T extends Node = Node> = string | T | Array<string | T>;

-declare type BoundEvent = [

+type Target = Node | Window;

+type RunArguments<T extends Node = Node> = string | T | Array<string | T> | null;

+type BoundEvent = [

Target,

string,

EventUtilsCallback<any>,

any

];

Target,

string,

EventUtilsCallback<any>,

any

];

-declare type Callback<K extends string> = EventUtilsCallback<MappedEvent<HTMLElementEventMap, K>>;

-declare type RunResult<T, R> = T extends Array<any> ? false | R[] : false | R;

+type Callback<K extends string> = EventUtilsCallback<MappedEvent<HTMLElementEventMap, K>>;

+type RunResult<T, R> = T extends Array<any> ? R[] : false | R;

interface DOMUtils {

doc: Document;

settings: Partial<DOMUtilsSettings>;

interface DOMUtils {

doc: Document;

settings: Partial<DOMUtilsSettings>;

styles: Styles;

schema: Schema;

events: EventUtils;

styles: Styles;

schema: Schema;

events: EventUtils;

- root: Node;

- isBlock: (node: string | Node) => boolean;

+ root: Node | null;

+ isBlock: {

+ (node: Node | null): node is HTMLElement;

+ (node: string): boolean;

+ };

clone: (node: Node, deep: boolean) => Node;

getRoot: () => HTMLElement;

getViewPort: (argWin?: Window) => GeomRect;

clone: (node: Node, deep: boolean) => Node;

getRoot: () => HTMLElement;

getViewPort: (argWin?: Window) => GeomRect;

h: number;

};

getParent: {

h: number;

};

getParent: {

- <K extends keyof HTMLElementTagNameMap>(node: string | Node, selector: K, root?: Node): HTMLElementTagNameMap[K] | null;

- <T extends HTMLElement>(node: string | Node, selector: (node: HTMLElement) => node is T, root?: Node): T | null;

- <T extends Element = Element>(node: string | Node, selector?: string | ((node: HTMLElement) => boolean | void), root?: Node): T | null;

+ <K extends keyof HTMLElementTagNameMap>(node: string | Node | null, selector: K, root?: Node): HTMLElementTagNameMap[K] | null;

+ <T extends Element>(node: string | Node | null, selector: string | ((node: Node) => node is T), root?: Node): T | null;

};

getParents: {

};

getParents: {

- <K extends keyof HTMLElementTagNameMap>(elm: string | Node, selector: K, root?: Node, collect?: boolean): Array<HTMLElementTagNameMap[K]>;

- <T extends HTMLElement>(node: string | Node, selector: (node: HTMLElement) => node is T, root?: Node): T[];

- <T extends Element = Element>(elm: string | Node, selector?: string | ((node: HTMLElement) => boolean | void), root?: Node, collect?: boolean): T[];

+ <K extends keyof HTMLElementTagNameMap>(elm: string | HTMLElementTagNameMap[K] | null, selector: K, root?: Node, collect?: boolean): Array<HTMLElementTagNameMap[K]>;

+ <T extends Element>(node: string | Node | null, selector: string | ((node: Node) => node is T), root?: Node, collect?: boolean): T[];

+ (elm: string | Node | null, selector?: string | ((node: Node) => boolean | void), root?: Node, collect?: boolean): Node[];

};

- get: (elm: string | Node) => HTMLElement | null;

- getNext: (node: Node, selector: string | ((node: Node) => boolean)) => Node | null;

- getPrev: (node: Node, selector: string | ((node: Node) => boolean)) => Node | null;

+ get: {

+ <T extends Node>(elm: T): T;

+ (elm: string): HTMLElement | null;

+ };

+ getNext: (node: Node | null, selector: string | ((node: Node) => boolean)) => Node | null;

+ getPrev: (node: Node | null, selector: string | ((node: Node) => boolean)) => Node | null;

select: {

<K extends keyof HTMLElementTagNameMap>(selector: K, scope?: string | Node): Array<HTMLElementTagNameMap[K]>;

<T extends HTMLElement = HTMLElement>(selector: string, scope?: string | Node): T[];

};

select: {

<K extends keyof HTMLElementTagNameMap>(selector: K, scope?: string | Node): Array<HTMLElementTagNameMap[K]>;

<T extends HTMLElement = HTMLElement>(selector: string, scope?: string | Node): T[];

};

- is: (elm: Node | Node[], selector: string) => boolean;

- add: (parentElm: RunArguments, name: string | Node, attrs?: Record<string, string | boolean | number>, html?: string | Node, create?: boolean) => HTMLElement;

+ is: {

+ <T extends Element>(elm: Node | Node[] | null, selector: string): elm is T;

+ (elm: Node | Node[] | null, selector: string): boolean;

+ };

create: {

- <K extends keyof HTMLElementTagNameMap>(name: K, attrs?: Record<string, string | boolean | number>, html?: string | Node): HTMLElementTagNameMap[K];

- (name: string, attrs?: Record<string, string | boolean | number>, html?: string | Node): HTMLElement;

};

- createHTML: (name: string, attrs?: Record<string, string>, html?: string) => string;

+ createHTML: (name: string, attrs?: Record<string, string | null>, html?: string) => string;

createFragment: (html?: string) => DocumentFragment;

- remove: <T extends Node>(node: string | T | T[], keepChildren?: boolean) => RunResult<typeof node, T>;

- setStyle: (elm: string | Node | Node[], name: string, value: string | number | null) => void;

- getStyle: (elm: string | Node, name: string, computed?: boolean) => string | undefined;

- setStyles: (elm: string | Node | Node[], stylesArg: StyleMap) => void;

+ remove: {

+ <T extends Node>(node: T | T[], keepChildren?: boolean): typeof node extends Array<any> ? T[] : T;

+ <T extends Node>(node: string, keepChildren?: boolean): T | false;

+ };

+ getStyle: {

+ (elm: Element, name: string, computed: true): string;

+ (elm: string | Element | null, name: string, computed?: boolean): string | undefined;

+ };

+ setStyle: (elm: string | Element | Element[], name: string, value: string | number | null) => void;

+ setStyles: (elm: string | Element | Element[], stylesArg: StyleMap) => void;

removeAllAttribs: (e: RunArguments<Element>) => void;

- getAttrib: (elm: string | Node, name: string, defaultVal?: string) => string;

- getPos: (elm: string | Node, rootElm?: Node) => {

+ setAttrib: (elm: RunArguments<Element>, name: string, value: string | boolean | number | null) => void;

+ setAttribs: (elm: RunArguments<Element>, attrs: Record<string, string | boolean | number | null>) => void;

+ getAttrib: (elm: string | Element | null, name: string, defaultVal?: string) => string;

+ getAttribs: (elm: string | Element) => NamedNodeMap | Attr[];

+ getPos: (elm: string | Element, rootElm?: Node) => {

x: number;

y: number;

};

x: number;

y: number;

};

serializeStyle: (stylesArg: StyleMap, name?: string) => string;

addStyle: (cssText: string) => void;

loadCSS: (url: string) => void;

serializeStyle: (stylesArg: StyleMap, name?: string) => string;

addStyle: (cssText: string) => void;

loadCSS: (url: string) => void;

- addClass: (elm: string | Node | Node[], cls: string) => void;

- removeClass: (elm: string | Node | Node[], cls: string) => void;

- hasClass: (elm: string | Node, cls: string) => boolean;

- toggleClass: (elm: string | Node | Node[], cls: string, state?: boolean) => void;

+ hasClass: (elm: string | Element, cls: string) => boolean;

+ addClass: (elm: RunArguments<Element>, cls: string) => void;

+ removeClass: (elm: RunArguments<Element>, cls: string) => void;

+ toggleClass: (elm: RunArguments<Element>, cls: string, state?: boolean) => void;

show: (elm: string | Node | Node[]) => void;

hide: (elm: string | Node | Node[]) => void;

isHidden: (elm: string | Node) => boolean;

uniqueId: (prefix?: string) => string;

show: (elm: string | Node | Node[]) => void;

hide: (elm: string | Node | Node[]) => void;

isHidden: (elm: string | Node) => boolean;

uniqueId: (prefix?: string) => string;

- setHTML: (elm: string | Node | Node[], html: string) => void;

+ setHTML: (elm: RunArguments<Element>, html: string) => void;

getOuterHTML: (elm: string | Node) => string;

setOuterHTML: (elm: string | Node | Node[], html: string) => void;

decode: (text: string) => string;

getOuterHTML: (elm: string | Node) => string;

setOuterHTML: (elm: string | Node | Node[], html: string) => void;

decode: (text: string) => string;

<K extends keyof HTMLElementTagNameMap>(elm: Element, name: K): HTMLElementTagNameMap[K];

(elm: Element, name: string): Element;

};

<K extends keyof HTMLElementTagNameMap>(elm: Element, name: K): HTMLElementTagNameMap[K];

(elm: Element, name: string): Element;

};

- findCommonAncestor: (a: Node, b: Node) => Node;

+ findCommonAncestor: (a: Node, b: Node) => Node | null;

run<R, T extends Node>(this: DOMUtils, elm: T | T[], func: (node: T) => R, scope?: any): typeof elm extends Array<any> ? R[] : R;

run<R, T extends Node>(this: DOMUtils, elm: RunArguments<T>, func: (node: T) => R, scope?: any): RunResult<typeof elm, R>;

run<R, T extends Node>(this: DOMUtils, elm: T | T[], func: (node: T) => R, scope?: any): typeof elm extends Array<any> ? R[] : R;

run<R, T extends Node>(this: DOMUtils, elm: RunArguments<T>, func: (node: T) => R, scope?: any): RunResult<typeof elm, R>;

- getAttribs: (elm: string | Node) => NamedNodeMap | Attr[];

- isEmpty: (node: Node, elements?: Record<string, any>) => boolean;

+ isEmpty: (node: Node, elements?: Record<string, any>, options?: ({

+ includeZwsp?: boolean;

+ })) => boolean;

createRng: () => Range;

nodeIndex: (node: Node, normalized?: boolean) => number;

split: {

createRng: () => Range;

nodeIndex: (node: Node, normalized?: boolean) => number;

split: {

- <T extends Node>(parentElm: Node, splitElm: Node, replacementElm: T): T;

- <T extends Node>(parentElm: Node, splitElm: T): T;

+ <T extends Node>(parentElm: Node, splitElm: Node, replacementElm: T): T | undefined;

+ <T extends Node>(parentElm: Node, splitElm: T): T | undefined;

};

bind: {

<K extends string>(target: Target, name: K, func: Callback<K>, scope?: any): Callback<K>;

};

bind: {

<K extends string>(target: Target, name: K, func: Callback<K>, scope?: any): Callback<K>;

dispatch: (target: Node | Window, name: string, evt?: {}) => EventUtils;

getContentEditable: (node: Node) => string | null;

getContentEditableParent: (node: Node) => string | null;

dispatch: (target: Node | Window, name: string, evt?: {}) => EventUtils;

getContentEditable: (node: Node) => string | null;

getContentEditableParent: (node: Node) => string | null;

+ isEditable: (node: Node | null | undefined) => boolean;

destroy: () => void;

isChildOf: (node: Node, parent: Node) => boolean;

dumpRng: (r: Range) => string;

destroy: () => void;

isChildOf: (node: Node, parent: Node) => boolean;

dumpRng: (r: Range) => string;

height: number;

}

interface BookmarkManager {

height: number;

}

interface BookmarkManager {

- getBookmark: (type: number, normalized?: boolean) => Bookmark;

+ getBookmark: (type?: number, normalized?: boolean) => Bookmark;

moveToBookmark: (bookmark: Bookmark) => void;

}

interface ControlSelection {

isResizable: (elm: Element) => boolean;

moveToBookmark: (bookmark: Bookmark) => void;

}

interface ControlSelection {

isResizable: (elm: Element) => boolean;

- showResizeRect: (elm: Element) => void;

+ showResizeRect: (elm: HTMLElement) => void;

hideResizeRect: () => void;

updateResizeRect: (evt: EditorEvent<any>) => void;

destroy: () => void;

hideResizeRect: () => void;

updateResizeRect: (evt: EditorEvent<any>) => void;

destroy: () => void;

indent_after?: string;

indent_before?: string;

}

indent_after?: string;

indent_before?: string;

}

-declare type Attributes = Array<{

+type Attributes = Array<{

value: string;

}>;

value: string;

}>;

getContent: () => string;

pi: (name: string, text?: string) => void;

reset: () => void;

getContent: () => string;

pi: (name: string, text?: string) => void;

reset: () => void;

- start: (name: string, attrs?: Attributes, empty?: boolean) => void;

+ start: (name: string, attrs?: Attributes | null, empty?: boolean) => void;

text: (text: string, raw?: boolean) => void;

}

interface HtmlSerializerSettings extends WriterSettings {

text: (text: string, raw?: boolean) => void;

}

interface HtmlSerializerSettings extends WriterSettings {

serialize: (node: AstNode) => string;

}

interface DomSerializerSettings extends DomParserSettings, WriterSettings, SchemaSettings, HtmlSerializerSettings {

serialize: (node: AstNode) => string;

}

interface DomSerializerSettings extends DomParserSettings, WriterSettings, SchemaSettings, HtmlSerializerSettings {

+ remove_trailing_brs?: boolean;

url_converter?: URLConverter;

url_converter_scope?: {};

}

url_converter?: URLConverter;

url_converter_scope?: {};

}

moveToBookmark: (bookmark: Bookmark) => void;

select: (node: Node, content?: boolean) => Node;

isCollapsed: () => boolean;

moveToBookmark: (bookmark: Bookmark) => void;

select: (node: Node, content?: boolean) => Node;

isCollapsed: () => boolean;

+ isEditable: () => boolean;

isForward: () => boolean;

setNode: (elm: Element) => Element;

isForward: () => boolean;

setNode: (elm: Element) => Element;

- getNode: () => Element;

+ getNode: () => HTMLElement;

getSel: () => Selection | null;

setRng: (rng: Range, forward?: boolean) => void;

getRng: () => Range;

getSel: () => Selection | null;

setRng: (rng: Range, forward?: boolean) => void;

getRng: () => Range;

selectorChanged: (selector: string, callback: (active: boolean, args: {

node: Node;

selector: String;

selectorChanged: (selector: string, callback: (active: boolean, args: {

node: Node;

selector: String;

- parents: Element[];

+ parents: Node[];

}) => void) => EditorSelection;

selectorChangedWithUnbind: (selector: string, callback: (active: boolean, args: {

node: Node;

selector: String;

}) => void) => EditorSelection;

selectorChangedWithUnbind: (selector: string, callback: (active: boolean, args: {

node: Node;

selector: String;

- parents: Element[];

+ parents: Node[];

}) => void) => {

unbind: () => void;

};

}) => void) => {

unbind: () => void;

};

- getScrollContainer: () => HTMLElement;

+ getScrollContainer: () => HTMLElement | undefined;

scrollIntoView: (elm?: HTMLElement, alignToTop?: boolean) => void;

placeCaretAt: (clientX: number, clientY: number) => void;

getBoundingClientRect: () => ClientRect | DOMRect;

destroy: () => void;

scrollIntoView: (elm?: HTMLElement, alignToTop?: boolean) => void;

placeCaretAt: (clientX: number, clientY: number) => void;

getBoundingClientRect: () => ClientRect | DOMRect;

destroy: () => void;

+ expand: (options?: {

+ type: 'word';

+ }) => void;

}

-declare type EditorCommandCallback = (ui: boolean, value: any) => void;

-declare type EditorCommandsCallback = (command: string, ui: boolean, value: any) => void;

+type EditorCommandCallback<S> = (this: S, ui: boolean, value: any) => void;

+type EditorCommandsCallback = (command: string, ui: boolean, value?: any) => void;

interface Commands {

state: Record<string, (command: string) => boolean>;

exec: Record<string, EditorCommandsCallback>;

interface Commands {

state: Record<string, (command: string) => boolean>;

exec: Record<string, EditorCommandsCallback>;

queryCommandValue(command: string): string;

addCommands<K extends keyof Commands>(commandList: Commands[K], type: K): void;

addCommands(commandList: Record<string, EditorCommandsCallback>): void;

queryCommandValue(command: string): string;

addCommands<K extends keyof Commands>(commandList: Commands[K], type: K): void;

addCommands(commandList: Record<string, EditorCommandsCallback>): void;

- addCommand(command: string, callback: EditorCommandCallback, scope?: any): void;

+ addCommand<S>(command: string, callback: EditorCommandCallback<S>, scope: S): void;

+ addCommand(command: string, callback: EditorCommandCallback<Editor>): void;

queryCommandSupported(command: string): boolean;

- addQueryStateHandler(command: string, callback: () => boolean, scope?: any): void;

- addQueryValueHandler(command: string, callback: () => string, scope?: any): void;

+ addQueryStateHandler<S>(command: string, callback: (this: S) => boolean, scope: S): void;

+ addQueryStateHandler(command: string, callback: (this: Editor) => boolean): void;

+ addQueryValueHandler<S>(command: string, callback: (this: S) => string, scope: S): void;

+ addQueryValueHandler(command: string, callback: (this: Editor) => string): void;

}

interface RawString {

raw: string;

}

interface RawString {

raw: string;

}

-declare type TokenisedString = [

+type TokenisedString = [

string,

...Primitive[]

];

string,

...Primitive[]

];

-declare type Untranslated = Primitive | TokenisedString | RawString;

-declare type TranslatedString = string;

+type Untranslated = Primitive | TokenisedString | RawString | null | undefined;

+type TranslatedString = string;

interface I18n {

getData: () => Record<string, Record<string, string>>;

setCode: (newCode: string) => void;

interface I18n {

getData: () => Record<string, Record<string, string>>;

setCode: (newCode: string) => void;

isRtl: () => boolean;

hasCode: (code: string) => boolean;

}

isRtl: () => boolean;

hasCode: (code: string) => boolean;

}

-interface Observable<T> {

+interface Observable<T extends {}> {

fire<K extends string, U extends MappedEvent<T, K>>(name: K, args?: U, bubble?: boolean): EditorEvent;

dispatch<K extends string, U extends MappedEvent<T, K>>(name: K, args?: U, bubble?: boolean): EditorEvent;

on<K extends string>(name: K, callback: (event: EditorEvent<MappedEvent<T, K>>) => void, prepend?: boolean): EventDispatcher<T>;

fire<K extends string, U extends MappedEvent<T, K>>(name: K, args?: U, bubble?: boolean): EditorEvent;

dispatch<K extends string, U extends MappedEvent<T, K>>(name: K, args?: U, bubble?: boolean): EditorEvent;

on<K extends string>(name: K, callback: (event: EditorEvent<MappedEvent<T, K>>) => void, prepend?: boolean): EventDispatcher<T>;

}

declare class URI {

static parseDataUri(uri: string): {

}

declare class URI {

static parseDataUri(uri: string): {

- type: string;

+ type: string | undefined;

data: string;

};

static isDomSafe(uri: string, context?: string, options?: SafeUriOptions): boolean;

data: string;

};

static isDomSafe(uri: string, context?: string, options?: SafeUriOptions): boolean;

pathname?: string;

}): string;

source: string;

pathname?: string;

}): string;

source: string;

- protocol: string;

- authority: string;

- userInfo: string;

- user: string;

- password: string;

- host: string;

- port: string;

- relative: string;

+ protocol: string | undefined;

+ authority: string | undefined;

+ userInfo: string | undefined;

+ user: string | undefined;

+ password: string | undefined;

+ host: string | undefined;

+ port: string | undefined;

+ relative: string | undefined;

path: string;

directory: string;

path: string;

directory: string;

- file: string;

- query: string;

- anchor: string;

+ file: string | undefined;

+ query: string | undefined;

+ anchor: string | undefined;

settings: URISettings;

constructor(url: string, settings?: URISettings);

setPath(path: string): void;

settings: URISettings;

constructor(url: string, settings?: URISettings);

setPath(path: string): void;

majorVersion: string;

minorVersion: string;

releaseDate: string;

majorVersion: string;

minorVersion: string;

releaseDate: string;

- activeEditor: Editor;

- focusedEditor: Editor;

+ activeEditor: Editor | null;

+ focusedEditor: Editor | null;

baseURI: URI;

baseURL: string;

documentBaseURL: string;

baseURI: URI;

baseURL: string;

documentBaseURL: string;

createEditor(this: EditorManager, id: string, options: RawEditorOptions): Editor;

execCommand(this: EditorManager, cmd: string, ui: boolean, value: any): boolean;

get(this: EditorManager): Editor[];

createEditor(this: EditorManager, id: string, options: RawEditorOptions): Editor;

execCommand(this: EditorManager, cmd: string, ui: boolean, value: any): boolean;

get(this: EditorManager): Editor[];

- get(this: EditorManager, id: number | string): Editor;

+ get(this: EditorManager, id: number | string): Editor | null;

init(this: EditorManager, options: RawEditorOptions): Promise<Editor[]>;

overrideDefaults(this: EditorManager, defaultOptions: Partial<RawEditorOptions>): void;

remove(this: EditorManager): void;

init(this: EditorManager, options: RawEditorOptions): Promise<Editor[]>;

overrideDefaults(this: EditorManager, defaultOptions: Partial<RawEditorOptions>): void;

remove(this: EditorManager): void;

- remove(this: EditorManager, selector: string | Editor): Editor | void;

+ remove(this: EditorManager, selector: string): void;

+ remove(this: EditorManager, editor: Editor): Editor | null;

setActive(this: EditorManager, editor: Editor): void;

setup(this: EditorManager): void;

translate: (text: Untranslated) => TranslatedString;

setActive(this: EditorManager, editor: Editor): void;

setup(this: EditorManager): void;

translate: (text: Untranslated) => TranslatedString;

}

interface EditorObservable extends Observable<EditorEventMap> {

bindPendingEventDelegates(this: Editor): void;

}

interface EditorObservable extends Observable<EditorEventMap> {

bindPendingEventDelegates(this: Editor): void;

- toggleNativeEvent(this: Editor, name: string, state: boolean): any;

+ toggleNativeEvent(this: Editor, name: string, state: boolean): void;

unbindAllNativeEvents(this: Editor): void;

}

interface ProcessorSuccess<T> {

unbindAllNativeEvents(this: Editor): void;

}

interface ProcessorSuccess<T> {

valid: false;

message: string;

}

valid: false;

message: string;

}

-declare type SimpleProcessor = (value: unknown) => boolean;

-declare type Processor<T> = (value: unknown) => ProcessorSuccess<T> | ProcessorError;

+type SimpleProcessor = (value: unknown) => boolean;

+type Processor<T> = (value: unknown) => ProcessorSuccess<T> | ProcessorError;

interface BuiltInOptionTypeMap {

'string': string;

'number': number;

interface BuiltInOptionTypeMap {

'string': string;

'number': number;

'object[]': any[];

'regexp': RegExp;

}

'object[]': any[];

'regexp': RegExp;

}

-declare type BuiltInOptionType = keyof BuiltInOptionTypeMap;

+type BuiltInOptionType = keyof BuiltInOptionTypeMap;

interface BaseOptionSpec {

immutable?: boolean;

deprecated?: boolean;

interface BaseOptionSpec {

immutable?: boolean;

deprecated?: boolean;

};

isRegistered: (name: string) => boolean;

get: {

};

isRegistered: (name: string) => boolean;

get: {

- <K extends keyof EditorOptions>(name: K): EditorOptions[K] | undefined;

+ <K extends keyof EditorOptions>(name: K): EditorOptions[K];

<T>(name: string): T | undefined;

};

set: <K extends string, T>(name: K, value: K extends keyof NormalizedEditorOptions ? NormalizedEditorOptions[K] : T) => boolean;

<T>(name: string): T | undefined;

};

set: <K extends string, T>(name: K, value: K extends keyof NormalizedEditorOptions ? NormalizedEditorOptions[K] : T) => boolean;

scanForImages: () => Promise<BlobInfoImagePair[]>;

destroy: () => void;

}

scanForImages: () => Promise<BlobInfoImagePair[]>;

destroy: () => void;

}

-declare type FormatChangeCallback = (state: boolean, data: {

+type FormatChangeCallback = (state: boolean, data: {

node: Node;

format: string;

node: Node;

format: string;

- parents: any;

+ parents: Element[];

}) => void;

interface FormatRegistry {

get: {

}) => void;

interface FormatRegistry {

get: {

unregister: (name: string) => Formats;

}

interface Formatter extends FormatRegistry {

unregister: (name: string) => Formats;

}

interface Formatter extends FormatRegistry {

- apply: (name: string, vars?: FormatVars, node?: Node | RangeLikeObject) => void;

+ apply: (name: string, vars?: FormatVars, node?: Node | RangeLikeObject | null) => void;

remove: (name: string, vars?: FormatVars, node?: Node | Range, similar?: boolean) => void;

toggle: (name: string, vars?: FormatVars, node?: Node) => void;

match: (name: string, vars?: FormatVars, node?: Node, similar?: boolean) => boolean;

closest: (names: string[]) => string | null;

matchAll: (names: string[], vars?: FormatVars) => string[];

remove: (name: string, vars?: FormatVars, node?: Node | Range, similar?: boolean) => void;

toggle: (name: string, vars?: FormatVars, node?: Node) => void;

match: (name: string, vars?: FormatVars, node?: Node, similar?: boolean) => boolean;

closest: (names: string[]) => string | null;

matchAll: (names: string[], vars?: FormatVars) => string[];

- matchNode: (node: Node, name: string, vars?: FormatVars, similar?: boolean) => Format | undefined;

+ matchNode: (node: Node | null, name: string, vars?: FormatVars, similar?: boolean) => Format | undefined;

canApply: (name: string) => boolean;

formatChanged: (names: string, callback: FormatChangeCallback, similar?: boolean, vars?: FormatVars) => {

unbind: () => void;

};

canApply: (name: string) => boolean;

formatChanged: (names: string, callback: FormatChangeCallback, similar?: boolean, vars?: FormatVars) => {

unbind: () => void;

};

- getCssText: (format: string | Format) => string;

+ getCssText: (format: string | ApplyFormat) => string;

}

interface EditorMode {

isReadOnly: () => boolean;

}

interface EditorMode {

isReadOnly: () => boolean;

readonly clearSelectedCells: (container: Node) => void;

};

}

readonly clearSelectedCells: (container: Node) => void;

};

}

-declare type ModelManager = AddOnManager<Model>;

+type ModelManager = AddOnManager<Model>;

interface Plugin {

getMetadata?: () => {

interface Plugin {

getMetadata?: () => {

init?: (editor: Editor, url: string) => void;

[key: string]: any;

}

init?: (editor: Editor, url: string) => void;

[key: string]: any;

}

-declare type PluginManager = AddOnManager<void | Plugin>;

+type PluginManager = AddOnManager<void | Plugin>;

interface ShortcutsConstructor {

readonly prototype: Shortcuts;

new (editor: Editor): Shortcuts;

}

interface ShortcutsConstructor {

readonly prototype: Shortcuts;

new (editor: Editor): Shortcuts;

}

-declare type CommandFunc = string | [

+type CommandFunc = string | [

string,

boolean,

any

string,

boolean,

any

private readonly shortcuts;

private pendingPatterns;

constructor(editor: Editor);

private readonly shortcuts;

private pendingPatterns;

constructor(editor: Editor);

- add(pattern: string, desc: string, cmdFunc: CommandFunc, scope?: any): boolean;

+ add(pattern: string, desc: string | null, cmdFunc: CommandFunc, scope?: any): boolean;

remove(pattern: string): boolean;

private normalizeCommandFunc;

private createShortcut;

remove(pattern: string): boolean;

private normalizeCommandFunc;

private createShortcut;

private matchShortcut;

private executeShortcutAction;

}

private matchShortcut;

private executeShortcutAction;

}

+interface RenderResult {

+ iframeContainer?: HTMLElement;

+ editorContainer: HTMLElement;

+ api?: Partial<EditorUiApi>;

+}

interface Theme {

ui?: any;

inline?: any;

execCommand?: (command: string, ui?: boolean, value?: any) => boolean;

destroy?: () => void;

init?: (editor: Editor, url: string) => void;

interface Theme {

ui?: any;

inline?: any;

execCommand?: (command: string, ui?: boolean, value?: any) => boolean;

destroy?: () => void;

init?: (editor: Editor, url: string) => void;

- renderUI?: () => {

- iframeContainer?: HTMLIFrameElement;

- editorContainer: HTMLElement;

- api?: Partial<EditorUiApi>;

- };

+ renderUI?: () => Promise<RenderResult> | RenderResult;

getNotificationManagerImpl?: () => NotificationManagerImpl;

getWindowManagerImpl?: () => WindowManagerImpl;

}

getNotificationManagerImpl?: () => NotificationManagerImpl;

getWindowManagerImpl?: () => WindowManagerImpl;

}

-declare type ThemeManager = AddOnManager<void | Theme>;

+type ThemeManager = AddOnManager<void | Theme>;

interface EditorConstructor {

readonly prototype: Editor;

new (id: string, options: RawEditorOptions, editorManager: EditorManager): Editor;

interface EditorConstructor {

readonly prototype: Editor;

new (id: string, options: RawEditorOptions, editorManager: EditorManager): Editor;

ui: EditorUi;

mode: EditorMode;

options: Options;

ui: EditorUi;

mode: EditorMode;

options: Options;

+ editorUpload: EditorUpload;

shortcuts: Shortcuts;

loadedCSS: Record<string, any>;

editorCommands: EditorCommands;

suffix: string;

editorManager: EditorManager;

shortcuts: Shortcuts;

loadedCSS: Record<string, any>;

editorCommands: EditorCommands;

suffix: string;

editorManager: EditorManager;

+ hidden: boolean;

inline: boolean;

+ hasVisual: boolean;

isNotDirty: boolean;

annotator: Annotator;

isNotDirty: boolean;

annotator: Annotator;

- bodyElement: HTMLElement;

+ bodyElement: HTMLElement | undefined;

bookmark: any;

composing: boolean;

container: HTMLElement;

contentAreaContainer: HTMLElement;

contentDocument: Document;

contentWindow: Window;

bookmark: any;

composing: boolean;

container: HTMLElement;

contentAreaContainer: HTMLElement;

contentDocument: Document;

contentWindow: Window;

- delegates: Record<string, (event: any) => void>;

+ delegates: Record<string, EventUtilsCallback<any>> | undefined;

destroyed: boolean;

dom: DOMUtils;

editorContainer: HTMLElement;

destroyed: boolean;

dom: DOMUtils;

editorContainer: HTMLElement;

- editorUpload: EditorUpload;

- eventRoot?: Element;

+ eventRoot: Element | undefined;

formatter: Formatter;

- formElement: HTMLElement;

- formEventDelegate: (e: Event) => void;

+ formElement: HTMLElement | undefined;

+ formEventDelegate: ((e: Event) => void) | undefined;

hasHiddenInput: boolean;

- hasVisual: boolean;

- hidden: boolean;

iframeElement: HTMLIFrameElement | null;

- iframeHTML: string;

+ iframeHTML: string | undefined;

initialized: boolean;

notificationManager: NotificationManager;

orgDisplay: string;

initialized: boolean;

notificationManager: NotificationManager;

orgDisplay: string;

- orgVisibility: string;

+ orgVisibility: string | undefined;

parser: DomParser;

quirks: Quirks;

readonly: boolean;

parser: DomParser;

quirks: Quirks;

readonly: boolean;

model: Model;

undoManager: UndoManager;

windowManager: WindowManager;

model: Model;

undoManager: UndoManager;

windowManager: WindowManager;

- _beforeUnload: () => void;

- _eventDispatcher: EventDispatcher<NativeEventMap>;

+ _beforeUnload: (() => void) | undefined;

+ _eventDispatcher: EventDispatcher<NativeEventMap> | undefined;

_nodeChangeDispatcher: NodeChange;

_pendingNativeEvents: string[];

_selectionOverrides: SelectionOverrides;

_skinLoaded: boolean;

_nodeChangeDispatcher: NodeChange;

_pendingNativeEvents: string[];

_selectionOverrides: SelectionOverrides;

_skinLoaded: boolean;

+ _editableRoot: boolean;

bindPendingEventDelegates: EditorObservable['bindPendingEventDelegates'];

toggleNativeEvent: EditorObservable['toggleNativeEvent'];

unbindAllNativeEvents: EditorObservable['unbindAllNativeEvents'];

bindPendingEventDelegates: EditorObservable['bindPendingEventDelegates'];

toggleNativeEvent: EditorObservable['toggleNativeEvent'];

unbindAllNativeEvents: EditorObservable['unbindAllNativeEvents'];

getParam<T>(name: string, defaultVal: T, type?: BuiltInOptionType): T;

hasPlugin(name: string, loaded?: boolean): boolean;

nodeChanged(args?: any): void;

getParam<T>(name: string, defaultVal: T, type?: BuiltInOptionType): T;

hasPlugin(name: string, loaded?: boolean): boolean;

nodeChanged(args?: any): void;

- addCommand(name: string, callback: EditorCommandCallback, scope?: object): void;

- addQueryStateHandler(name: string, callback: () => boolean, scope?: any): void;

- addQueryValueHandler(name: string, callback: () => string, scope?: any): void;

+ addCommand<S>(name: string, callback: EditorCommandCallback<S>, scope: S): void;

+ addCommand(name: string, callback: EditorCommandCallback<Editor>): void;

+ addQueryStateHandler<S>(name: string, callback: (this: S) => boolean, scope?: S): void;

+ addQueryStateHandler(name: string, callback: (this: Editor) => boolean): void;

+ addQueryValueHandler<S>(name: string, callback: (this: S) => string, scope: S): void;

+ addQueryValueHandler(name: string, callback: (this: Editor) => string): void;

addShortcut(pattern: string, desc: string, cmdFunc: string | [

string,

boolean,

addShortcut(pattern: string, desc: string, cmdFunc: string | [

string,

boolean,

hide(): void;

isHidden(): boolean;

setProgressState(state: boolean, time?: number): void;

hide(): void;

isHidden(): boolean;

setProgressState(state: boolean, time?: number): void;

- load(args?: any): string;

- save(args?: any): string;

+ load(args?: Partial<SetContentArgs>): string;

+ save(args?: Partial<GetContentArgs>): string;

setContent(content: string, args?: Partial<SetContentArgs>): string;

setContent(content: AstNode, args?: Partial<SetContentArgs>): AstNode;

setContent(content: Content, args?: Partial<SetContentArgs>): Content;

setContent(content: string, args?: Partial<SetContentArgs>): string;

setContent(content: AstNode, args?: Partial<SetContentArgs>): AstNode;

setContent(content: Content, args?: Partial<SetContentArgs>): Content;

getWin(): Window;

getDoc(): Document;

getBody(): HTMLElement;

getWin(): Window;

getDoc(): Document;

getBody(): HTMLElement;

- convertURL(url: string, name: string, elm?: any): string;

+ convertURL(url: string, name: string, elm?: string | Element): string;

addVisual(elm?: HTMLElement): void;

+ setEditableRoot(state: boolean): void;

+ hasEditableRoot(): boolean;

remove(): void;

destroy(automatic?: boolean): void;

uploadImages(): Promise<UploadResult$1[]>;

remove(): void;

destroy(automatic?: boolean): void;

uploadImages(): Promise<UploadResult$1[]>;

resource: string;

suffix: string;

}

resource: string;

suffix: string;

}

-declare type WaitState = 'added' | 'loaded';

-declare type AddOnConstructor<T> = (editor: Editor, url: string) => T;

+type WaitState = 'added' | 'loaded';

+type AddOnConstructor<T> = (editor: Editor, url: string) => T;

interface AddOnManager<T> {

items: AddOnConstructor<T>[];

urls: Record<string, string>;

lookup: Record<string, {

instance: AddOnConstructor<T>;

}>;

interface AddOnManager<T> {

items: AddOnConstructor<T>[];

urls: Record<string, string>;

lookup: Record<string, {

instance: AddOnConstructor<T>;

}>;

- get: (name: string) => AddOnConstructor<T>;

- requireLangPack: (name: string, languages: string) => void;

+ get: (name: string) => AddOnConstructor<T> | undefined;

+ requireLangPack: (name: string, languages?: string) => void;

add: (id: string, addOn: AddOnConstructor<T>) => AddOnConstructor<T>;

remove: (name: string) => void;

createUrl: (baseUrl: UrlObject, dep: string | UrlObject) => UrlObject;

add: (id: string, addOn: AddOnConstructor<T>) => AddOnConstructor<T>;

remove: (name: string) => void;

createUrl: (baseUrl: UrlObject, dep: string | UrlObject) => UrlObject;

walk: (rng: Range, callback: (nodes: Node[]) => void) => void;

split: (rng: Range) => RangeLikeObject;

normalize: (rng: Range) => boolean;

walk: (rng: Range, callback: (nodes: Node[]) => void) => void;

split: (rng: Range) => RangeLikeObject;

normalize: (rng: Range) => boolean;

+ expand: (rng: Range, options?: {

+ type: 'word';

+ }) => Range;

}

interface ScriptLoaderSettings {

referrerPolicy?: ReferrerPolicy;

}

interface ScriptLoaderSettings {

referrerPolicy?: ReferrerPolicy;

loadQueue(): Promise<void>;

loadScripts(scripts: string[]): Promise<void>;

}

loadQueue(): Promise<void>;

loadScripts(scripts: string[]): Promise<void>;

}

-declare type TextProcessCallback = (node: Text, offset: number, text: string) => number;

+type TextProcessCallback = (node: Text, offset: number, text: string) => number;

interface Spot {

container: Text;

offset: number;

interface Spot {

container: Text;

offset: number;

private readonly rootNode;

private node;

constructor(startNode: Node, rootNode: Node);

private readonly rootNode;

private node;

constructor(startNode: Node, rootNode: Node);

- current(): Node | undefined;

- next(shallow?: boolean): Node | undefined;

- prev(shallow?: boolean): Node | undefined;

- prev2(shallow?: boolean): Node | undefined;

+ current(): Node | null | undefined;

+ next(shallow?: boolean): Node | null | undefined;

+ prev(shallow?: boolean): Node | null | undefined;

+ prev2(shallow?: boolean): Node | null | undefined;

private findSibling;

private findPreviousNode;

}

private findSibling;

private findPreviousNode;

}

encodeAllRaw: (text: string) => string;

encodeNumeric: (text: string, attr?: boolean) => string;

encodeNamed: (text: string, attr?: boolean, entities?: EntitiesMap) => string;

encodeAllRaw: (text: string) => string;

encodeNumeric: (text: string, attr?: boolean) => string;

encodeNamed: (text: string, attr?: boolean, entities?: EntitiesMap) => string;

- getEncodeFunc: (name: string, entities?: EntitiesMap | string) => (text: string, attr?: boolean) => string;

+ getEncodeFunc: (name: string, entities?: string) => (text: string, attr?: boolean) => string;

decode: (text: string) => string;

}

interface IconPack {

decode: (text: string) => string;

}

interface IconPack {

interface Resource {

load: <T = any>(id: string, url: string) => Promise<T>;

add: (id: string, data: any) => void;

interface Resource {

load: <T = any>(id: string, url: string) => Promise<T>;

add: (id: string, data: any) => void;

+ has: (id: string) => boolean;

+ get: (id: string) => any;

unload: (id: string) => void;

}

unload: (id: string) => void;

}

+type TextPatterns_d_Pattern = Pattern;

+type TextPatterns_d_RawPattern = RawPattern;

+type TextPatterns_d_DynamicPatternsLookup = DynamicPatternsLookup;

+type TextPatterns_d_RawDynamicPatternsLookup = RawDynamicPatternsLookup;

+type TextPatterns_d_DynamicPatternContext = DynamicPatternContext;

+type TextPatterns_d_BlockCmdPattern = BlockCmdPattern;

+type TextPatterns_d_BlockPattern = BlockPattern;

+type TextPatterns_d_BlockFormatPattern = BlockFormatPattern;

+type TextPatterns_d_InlineCmdPattern = InlineCmdPattern;

+type TextPatterns_d_InlinePattern = InlinePattern;

+type TextPatterns_d_InlineFormatPattern = InlineFormatPattern;

+declare namespace TextPatterns_d {

+ export { TextPatterns_d_Pattern as Pattern, TextPatterns_d_RawPattern as RawPattern, TextPatterns_d_DynamicPatternsLookup as DynamicPatternsLookup, TextPatterns_d_RawDynamicPatternsLookup as RawDynamicPatternsLookup, TextPatterns_d_DynamicPatternContext as DynamicPatternContext, TextPatterns_d_BlockCmdPattern as BlockCmdPattern, TextPatterns_d_BlockPattern as BlockPattern, TextPatterns_d_BlockFormatPattern as BlockFormatPattern, TextPatterns_d_InlineCmdPattern as InlineCmdPattern, TextPatterns_d_InlinePattern as InlinePattern, TextPatterns_d_InlineFormatPattern as InlineFormatPattern, };

+}

interface Delay {

setEditorInterval: (editor: Editor, callback: () => void, time?: number) => number;

setEditorTimeout: (editor: Editor, callback: () => void, time?: number) => number;

}

interface Delay {

setEditorInterval: (editor: Editor, callback: () => void, time?: number) => number;

setEditorTimeout: (editor: Editor, callback: () => void, time?: number) => number;

}

-declare type UploadResult = UploadResult$2;

+type UploadResult = UploadResult$2;

interface ImageUploader {

upload: (blobInfos: BlobInfo[], showNotification?: boolean) => Promise<UploadResult[]>;

}

interface ImageUploader {

upload: (blobInfos: BlobInfo[], showNotification?: boolean) => Promise<UploadResult[]>;

}

-declare type ArrayCallback$1<T, R> = (x: T, i: number, xs: ReadonlyArray<T>) => R;

-declare type ObjCallback$1<T, R> = (value: T, key: string, obj: Record<string, T>) => R;

-declare type ArrayCallback<T, R> = ArrayCallback$1<T, R>;

-declare type ObjCallback<T, R> = ObjCallback$1<T, R>;

+type ArrayCallback$1<T, R> = (this: any, x: T, i: number, xs: ArrayLike<T>) => R;

+type ObjCallback$1<T, R> = (this: any, value: T, key: string, obj: Record<string, T>) => R;

+type ArrayCallback<T, R> = ArrayCallback$1<T, R>;

+type ObjCallback<T, R> = ObjCallback$1<T, R>;

+type WalkCallback<T> = (this: any, o: T, i: string, n: keyof T | undefined) => boolean | void;

interface Tools {

- is: (obj: any, type: string) => boolean;

+ is: (obj: any, type?: string) => boolean;

isArray: <T>(arr: any) => arr is Array<T>;

inArray: <T>(arr: ArrayLike<T>, value: T) => number;

grep: {

isArray: <T>(arr: any) => arr is Array<T>;

inArray: <T>(arr: ArrayLike<T>, value: T) => number;

grep: {

trim: (str: string | null | undefined) => string;

toArray: <T>(obj: ArrayLike<T>) => T[];

hasOwn: (obj: any, name: string) => boolean;

trim: (str: string | null | undefined) => string;

toArray: <T>(obj: ArrayLike<T>) => T[];

hasOwn: (obj: any, name: string) => boolean;

- makeMap: <T>(items: ArrayLike<T> | string, delim?: string | RegExp, map?: Record<string, T | string>) => Record<string, T | string>;

+ makeMap: (items: ArrayLike<string> | string | undefined, delim?: string | RegExp, map?: Record<string, {}>) => Record<string, {}>;

each: {

<T>(arr: ArrayLike<T> | null | undefined, cb: ArrayCallback<T, void | boolean>, scope?: any): boolean;

<T>(obj: Record<string, T> | null | undefined, cb: ObjCallback<T, void | boolean>, scope?: any): boolean;

each: {

<T>(arr: ArrayLike<T> | null | undefined, cb: ArrayCallback<T, void | boolean>, scope?: any): boolean;

<T>(obj: Record<string, T> | null | undefined, cb: ObjCallback<T, void | boolean>, scope?: any): boolean;

<T, R>(obj: Record<string, T> | null | undefined, cb: ObjCallback<T, R>): R[];

};

extend: (obj: Object, ext: Object, ...objs: Object[]) => any;

<T, R>(obj: Record<string, T> | null | undefined, cb: ObjCallback<T, R>): R[];

};

extend: (obj: Object, ext: Object, ...objs: Object[]) => any;

- walk: <T = any>(obj: T, f: Function, n?: keyof T, scope?: any) => void;

+ walk: <T extends Record<string, any>>(obj: T, f: WalkCallback<T>, n?: keyof T, scope?: any) => void;

resolve: (path: string, o?: Object) => any;

- explode: (s: string, d?: string | RegExp) => string[];

+ explode: (s: string | string[], d?: string | RegExp) => string[];

_addCacheSuffix: (url: string) => string;

}

interface KeyboardLikeEvent {

_addCacheSuffix: (url: string) => string;

}

interface KeyboardLikeEvent {

_addCacheSuffix: Tools['_addCacheSuffix'];

}

declare const tinymce: TinyMCE;

_addCacheSuffix: Tools['_addCacheSuffix'];

}

declare const tinymce: TinyMCE;

-export { AddOnManager, Annotator, AstNode, Bookmark, BookmarkManager, ControlSelection, DOMUtils, Delay, DomParser, DomParserSettings, DomSerializer, DomSerializerSettings, DomTreeWalker, Editor, EditorCommands, EditorEvent, EditorManager, EditorModeApi, EditorObservable, EditorOptions, EditorSelection, Entities, Env, EventDispatcher, EventUtils, EventTypes_d as Events, FakeClipboard, FocusManager, Format_d as Formats, Formatter, GeomRect, HtmlSerializer, HtmlSerializerSettings, I18n, IconManager, Model, ModelManager, NotificationApi, NotificationManager, NotificationSpec, Observable, Plugin, PluginManager, RangeUtils, RawEditorOptions, Rect, Resource, Schema, SchemaSettings, ScriptLoader, Shortcuts, StyleSheetLoader, Styles, TextSeeker, Theme, ThemeManager, TinyMCE, Tools, URI, Ui_d as Ui, UndoManager, VK, WindowManager, Writer, WriterSettings, tinymce as default };

+export { AddOnManager, Annotator, AstNode, Bookmark, BookmarkManager, ControlSelection, DOMUtils, Delay, DomParser, DomParserSettings, DomSerializer, DomSerializerSettings, DomTreeWalker, Editor, EditorCommands, EditorEvent, EditorManager, EditorModeApi, EditorObservable, EditorOptions, EditorSelection, Entities, Env, EventDispatcher, EventUtils, EventTypes_d as Events, FakeClipboard, FocusManager, Format_d as Formats, Formatter, GeomRect, HtmlSerializer, HtmlSerializerSettings, I18n, IconManager, Model, ModelManager, NotificationApi, NotificationManager, NotificationSpec, Observable, Plugin, PluginManager, RangeUtils, RawEditorOptions, Rect, Resource, Schema, SchemaSettings, ScriptLoader, Shortcuts, StyleSheetLoader, Styles, TextPatterns_d as TextPatterns, TextSeeker, Theme, ThemeManager, TinyMCE, Tools, URI, Ui_d as Ui, UndoManager, VK, WindowManager, Writer, WriterSettings, tinymce as default };