tinymce

tinymce

Version 8.0.2
Published 10 days ago
10.5 MB
No dependencies
GPL-2.0-or-later license

Install

npm i tinymce

yarn add tinymce

pnpm add tinymce

Overview

Web based JavaScript HTML WYSIWYG editor control.

Index

Variables

variable tinymce

const tinymce: TinyMCE;

Classes

class AstNode

class AstNode {}

constructor

constructor(name: string, type: number);

property attributes

attributes?: { name: string; value: string }[] & { map: Record<string, string> };

property firstChild

firstChild?: AstNode;

property lastChild

lastChild?: AstNode;

property name

name: string;

property next

next?: AstNode;

property parent

parent?: AstNode;

property prev

prev?: AstNode;

property raw

raw?: boolean;

property type

type: number;

property value

value?: string;

method append

append: (node: AstNode) => AstNode;

method attr

attr: {
    (name: string, value: string | null | undefined): AstNode | undefined;
    (name: Record<string, string>): AstNode;
    (name: string): string;
};

method children

children: () => AstNode[];

method clone

clone: () => AstNode;

method create

static create: (name: string, attrs?: Record<string, string>) => AstNode;

method empty

empty: () => AstNode;

method getAll

getAll: (name: string) => AstNode[];

method insert

insert: (node: AstNode, refNode: AstNode, before?: boolean) => AstNode;

method isEmpty

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

method remove

remove: () => AstNode;

method replace

replace: (node: AstNode) => AstNode;

method unwrap

unwrap: () => void;

method walk

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

method wrap

wrap: (wrapper: AstNode) => AstNode;

class DomTreeWalker

class DomTreeWalker {}

constructor

constructor(startNode: Node, rootNode: Node);

method current

current: () => Node | null | undefined;

method next

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

method prev

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

method prev2

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

class Editor

class Editor implements EditorObservable {}

constructor

constructor(id: string, options: RawEditorOptions, editorManager: EditorManager);

property annotator

annotator: Annotator;

property baseUri

baseUri: URI;

property baseURI

baseURI: URI;

property bindPendingEventDelegates

bindPendingEventDelegates: (this: Editor) => void;

property bodyElement

bodyElement: HTMLElement;

property bookmark

bookmark: any;

property composing

composing: boolean;

property container

container: HTMLElement;

property contentAreaContainer

contentAreaContainer: HTMLElement;

property contentCSS

contentCSS: string[];

property contentDocument

contentDocument: Document;

property contentStyles

contentStyles: string[];

property contentWindow

contentWindow: Window;

property delegates

delegates: Record<string, EventUtilsCallback<any>>;

property destroyed

destroyed: boolean;

property dispatch

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

property documentBaseURI

documentBaseURI: URI;

property dom

dom: DOMUtils;

property editorCommands

editorCommands: EditorCommands;

property editorContainer

editorContainer: HTMLElement;

property editorManager

editorManager: EditorManager;

property editorUid

editorUid: string;

property editorUpload

editorUpload: EditorUpload;

property eventRoot

eventRoot: Element;

property fire

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

property formatter

formatter: Formatter;

property formElement

formElement: HTMLElement;

property formEventDelegate

formEventDelegate: (e: Event) => void;

property hasEventListeners

hasEventListeners: (name: string) => boolean;

property hasHiddenInput

hasHiddenInput: boolean;

property hasVisual

hasVisual: boolean;

property hidden

hidden: boolean;

property id

id: string;

property iframeElement

iframeElement: HTMLIFrameElement;

property iframeHTML

iframeHTML: string;

property initialized

initialized: boolean;

property inline

inline: boolean;

property isNotDirty

isNotDirty: boolean;

property licenseKeyManager

licenseKeyManager: LicenseKeyManager;

property loadedCSS

loadedCSS: Record<string, any>;

property mode

mode: EditorMode;

property model

model: Model;

property notificationManager

notificationManager: NotificationManager;

property off

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

property on

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

property once

once: <K extends string>(
    name: K,
    callback: (event: EditorEvent<MappedEvent<EditorEventMap, K>>) => void
) => EventDispatcher<EditorEventMap>;

property options

options: Options;

property orgDisplay

orgDisplay: string;

property orgVisibility

orgVisibility: string;

property parser

parser: DomParser;

property plugins

plugins: Record<string, Plugin>;

property quirks

quirks: Quirks;

property readonly

readonly: boolean;

property removed

removed: boolean;

property schema

schema: Schema;

property selection

selection: EditorSelection;

property serializer

serializer: DomSerializer;

property shortcuts

shortcuts: Shortcuts;

property startContent

startContent: string;

property suffix

suffix: string;

property targetElm

targetElm: HTMLElement;

property theme

theme: Theme;

property toggleNativeEvent

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

property ui

ui: EditorUi;

property unbindAllNativeEvents

unbindAllNativeEvents: (this: Editor) => void;

property undoManager

undoManager: UndoManager;

property userLookup

userLookup: UserLookup;

property windowManager

windowManager: WindowManager;

method addCommand

addCommand: {
    <S>(name: string, callback: EditorCommandCallback<S>, scope: S): void;
    (name: string, callback: EditorCommandCallback<Editor>): void;
};

method addQueryStateHandler

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

method addQueryValueHandler

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

method addShortcut

addShortcut: (
    pattern: string,
    desc: string,
    cmdFunc: string | [string, boolean, any] | (() => void),
    scope?: any
) => void;

method addVisual

addVisual: (elm?: HTMLElement) => void;

method convertURL

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

method destroy

destroy: (automatic?: boolean) => void;

method execCommand

execCommand: (
    cmd: string,
    ui?: boolean,
    value?: any,
    args?: ExecCommandArgs
) => boolean;

method focus

focus: (skipFocus?: boolean) => void;

method getBody

getBody: () => HTMLElement;

method getContainer

getContainer: () => HTMLElement;

method getContent

getContent: {
    (args: { format: 'tree' } & Partial<GetContentArgs>): AstNode;
    (args?: Partial<GetContentArgs>): string;
};

method getContentAreaContainer

getContentAreaContainer: () => HTMLElement;

method getDoc

getDoc: () => Document;

method getElement

getElement: () => HTMLElement;

method getParam

getParam: {
    <K extends keyof BuiltInOptionTypeMap>(
        name: string,
        defaultVal: BuiltInOptionTypeMap[K],
        type: K
    ): BuiltInOptionTypeMap[K];
    <K extends keyof NormalizedEditorOptions>(
        name: K,
        defaultVal?: NormalizedEditorOptions[K],
        type?: keyof BuiltInOptionTypeMap
    ): NormalizedEditorOptions[K];
    <T>(name: string, defaultVal: T, type?: keyof BuiltInOptionTypeMap): T;
};

method getWin

getWin: () => Window;

method hasEditableRoot

hasEditableRoot: () => boolean;

method hasFocus

hasFocus: () => boolean;

method hasPlugin

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

method hide

hide: () => void;

method insertContent

insertContent: (content: string, args?: any) => void;

method isDirty

isDirty: () => boolean;

method isHidden

isHidden: () => boolean;

method load

load: (args?: Partial<SetContentArgs>) => void;

method nodeChanged

nodeChanged: (args?: any) => void;

method queryCommandState

queryCommandState: (cmd: string) => boolean;

method queryCommandSupported

queryCommandSupported: (cmd: string) => boolean;

method queryCommandValue

queryCommandValue: (cmd: string) => string;

method remove

remove: () => void;

method render

render: () => void;

method resetContent

resetContent: (initialContent?: string) => void;

method save

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

method setContent

setContent: (content: string | AstNode, args?: Partial<SetContentArgs>) => void;

method setDirty

setDirty: (state: boolean) => void;

method setEditableRoot

setEditableRoot: (state: boolean) => void;

method setProgressState

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

method show

show: () => void;

method translate

translate: (text: Untranslated) => TranslatedString;

method uploadImages

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

class EditorCommands

class EditorCommands {}

constructor

constructor(editor: Editor);

method addCommand

addCommand: {
    <S>(command: string, callback: EditorCommandCallback<S>, scope: S): void;
    (command: string, callback: EditorCommandCallback<Editor>): void;
};

method addCommands

addCommands: {
    <K extends keyof Commands>(commandList: Commands[K], type: K): void;
    (commandList: Record<string, EditorCommandsCallback>): void;
};

method addQueryStateHandler

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

method addQueryValueHandler

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

method execCommand

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

method queryCommandState

queryCommandState: (command: string) => boolean;

method queryCommandSupported

queryCommandSupported: (command: string) => boolean;

method queryCommandValue

queryCommandValue: (command: string) => string;

class EventDispatcher

class EventDispatcher<T extends {}> {}

constructor

constructor(settings?: EventDispatcherSettings);

method dispatch

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

method fire

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

method has

has: (name: string) => boolean;

method isNative

static isNative: (name: string) => boolean;

method off

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

method on

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

method once

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

class EventUtils

class EventUtils {}

constructor

constructor();

property domLoaded

domLoaded: boolean;

property Event

static Event: EventUtils;

property events

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

method bind

bind: {
    <K extends keyof HTMLElementEventMap>(
        target: any,
        name: K,
        callback: EventUtilsCallback<HTMLElementEventMap[K]>,
        scope?: any
    ): EventUtilsCallback<HTMLElementEventMap[K]>;
    <T = any>(
        target: any,
        names: string,
        callback: EventUtilsCallback<T>,
        scope?: any
    ): EventUtilsCallback<T>;
};

method cancel

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

method clean

clean: (target: any) => this;

method destroy

destroy: () => void;

method dispatch

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

method fire

fire: (target: any, name: string, args?: {}) => this;

method unbind

unbind: {
    <K extends keyof HTMLElementEventMap>(
        target: any,
        name: K,
        callback?: EventUtilsCallback<HTMLElementEventMap[K]>
    ): this;
    <T = any>(
        target: any,
        names: string,
        callback?: EventUtilsCallback<T>
    ): this;
    (target: any): this;
};

class ScriptLoader

class ScriptLoader {}

constructor

constructor(settings?: ScriptLoaderSettings);

property ScriptLoader

static ScriptLoader: ScriptLoader;

method add

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

method isDone

isDone: (url: string) => boolean;

method load

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

method loadQueue

loadQueue: () => Promise<void>;

method loadScript

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

method loadScripts

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

method markDone

markDone: (url: string) => void;

method remove

remove: (url: string) => void;

class Shortcuts

class Shortcuts {}

constructor

constructor(editor: Editor);

method add

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

method remove

remove: (pattern: string) => boolean;

class URI

class URI {}

constructor

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

property anchor

anchor: string;

property authority

authority: string;

property directory

directory: string;

property file

file: string;

property host

host: string;

property password

password: string;

property path

path: string;

property port

port: string;

property protocol

protocol: string;

property query

query: string;

property relative

relative: string;

property settings

settings: URISettings;

property source

source: string;

property user

user: string;

property userInfo

userInfo: string;

method getDocumentBaseUrl

static getDocumentBaseUrl: (loc: {
    protocol: string;
    host?: string;
    href?: string;
    pathname?: string;
}) => string;

method getURI

getURI: (noProtoHost?: boolean) => string;

method isDomSafe

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

method isSameOrigin

isSameOrigin: (uri: URI) => boolean;

method parseDataUri

static parseDataUri: (uri: string) => { type: string | undefined; data: string };

method setPath

setPath: (path: string) => void;

method toAbsolute

toAbsolute: (uri: string, noHost?: boolean) => string;

method toAbsPath

toAbsPath: (base: string, path: string) => string;

method toRelative

toRelative: (uri: string) => string;

method toRelPath

toRelPath: (base: string, path: string) => string;

Interfaces

interface AddOnManager

interface AddOnManager<T> {}

property add

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

property createUrl

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

property get

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

property items

items: AddOnConstructor<T>[];

property load

load: (name: string, addOnUrl: string | UrlObject) => Promise<void>;

property lookup

lookup: Record<
    string,
    {
        instance: AddOnConstructor<T>;
    }
>;

property remove

remove: (name: string) => void;

property requireLangPack

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

property urls

urls: Record<string, string>;

property waitFor

waitFor: (name: string, state?: WaitState) => Promise<void>;

interface Annotator

interface Annotator {}

property annotate

annotate: (name: string, data: DecoratorData) => void;

property annotationChanged

annotationChanged: (name: string, f: AnnotationListenerApi) => void;

property getAll

getAll: (name: string) => Record<string, Element[]>;

property register

register: (name: string, settings: AnnotatorSettings) => void;

property remove

remove: (name: string) => void;

property removeAll

removeAll: (name: string) => void;

interface BookmarkManager

interface BookmarkManager {}

property getBookmark

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

property moveToBookmark

moveToBookmark: (bookmark: Bookmark) => void;

interface ControlSelection

interface ControlSelection {}

property destroy

destroy: () => void;

property hideResizeRect

hideResizeRect: () => void;

property isResizable

isResizable: (elm: Element) => boolean;

property showResizeRect

showResizeRect: (elm: HTMLElement) => void;

property updateResizeRect

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

interface Delay

interface Delay {}

property setEditorInterval

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

property setEditorTimeout

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

interface DomParser

interface DomParser {}

property addAttributeFilter

addAttributeFilter: (name: string, callback: ParserFilterCallback) => void;

property addNodeFilter

addNodeFilter: (name: string, callback: ParserFilterCallback) => void;

property getAttributeFilters

getAttributeFilters: () => ParserFilter[];

property getNodeFilters

getNodeFilters: () => ParserFilter[];

property parse

parse: (html: string, args?: ParserArgs) => AstNode;

property removeAttributeFilter

removeAttributeFilter: (name: string, callback?: ParserFilterCallback) => void;

property removeNodeFilter

removeNodeFilter: (name: string, callback?: ParserFilterCallback) => void;

property schema

schema: Schema;

interface DomParserSettings

interface DomParserSettings {}

property allow_conditional_comments

allow_conditional_comments?: boolean;

property allow_html_data_urls

allow_html_data_urls?: boolean;

property allow_html_in_comments

allow_html_in_comments?: boolean;

property allow_html_in_named_anchor

allow_html_in_named_anchor?: boolean;

property allow_mathml_annotation_encodings

allow_mathml_annotation_encodings?: string[];

property allow_script_urls

allow_script_urls?: boolean;

property allow_svg_data_urls

allow_svg_data_urls?: boolean;

property allow_unsafe_link_target

allow_unsafe_link_target?: boolean;

property blob_cache

blob_cache?: BlobCache;

property convert_fonts_to_spans

convert_fonts_to_spans?: boolean;

property convert_unsafe_embeds

convert_unsafe_embeds?: boolean;

property document

document?: Document;

property extended_mathml_attributes

extended_mathml_attributes?: string[];

property extended_mathml_elements

extended_mathml_elements?: string[];

property fix_list_elements

fix_list_elements?: boolean;

property font_size_legacy_values

font_size_legacy_values?: string;

property forced_root_block

forced_root_block?: boolean | string;

property forced_root_block_attrs

forced_root_block_attrs?: Record<string, string>;

property inline_styles

inline_styles?: boolean;

property pad_empty_with_br

pad_empty_with_br?: boolean;

property preserve_cdata

preserve_cdata?: boolean;

property root_name

root_name?: string;

property sandbox_iframes

sandbox_iframes?: boolean;

property sandbox_iframes_exclusions

sandbox_iframes_exclusions?: string[];

property sanitize

sanitize?: boolean;

property validate

validate?: boolean;

interface DomSerializer

interface DomSerializer extends DomSerializerImpl {}

interface DomSerializerSettings

interface DomSerializerSettings
    extends DomParserSettings,
        WriterSettings,
        SchemaSettings,
        HtmlSerializerSettings {}

property remove_trailing_brs

remove_trailing_brs?: boolean;

property url_converter

url_converter?: URLConverter;

property url_converter_scope

url_converter_scope?: {};

interface DOMUtils

interface DOMUtils {}

property add

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

property addClass

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

property addStyle

addStyle: (cssText: string) => void;

property bind

bind: {
    <K extends string>(
        target: Target,
        name: K,
        func: Callback<K>,
        scope?: any
    ): Callback<K>;
    <K extends string>(
        target: Target[],
        name: K,
        func: Callback<K>,
        scope?: any
    ): Callback<K>[];
};

property boundEvents

boundEvents: BoundEvent[];

property boxModel

boxModel: boolean;

property clone

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

property create

create: {
    <K extends keyof HTMLElementTagNameMap>(
        name: K,
        attrs?: Record<string, string | boolean | number | null>,
        html?: string | Node | null
    ): HTMLElementTagNameMap[K];
    (
        name: string,
        attrs?: Record<string, string | boolean | number | null>,
        html?: string | Node | null
    ): HTMLElement;
};

property createFragment

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

property createHTML

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

property createRng

createRng: () => Range;

property decode

decode: (text: string) => string;

property destroy

destroy: () => void;

property dispatch

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

property doc

doc: Document;

property dumpRng

dumpRng: (r: Range) => string;

property encode

encode: (text: string) => string;

property events

events: EventUtils;

property files

files: Record<string, boolean>;

property findCommonAncestor

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

property fire

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

property get

get: {
    <T extends Node>(elm: T): T;
    (elm: string): HTMLElement | null;
};

property getAttrib

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

property getAttribs

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

property getContentEditable

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

property getContentEditableParent

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

property getNext

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

property getOuterHTML

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

property getParent

getParent: {
    <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;
    (
        node: string | Node | null,
        selector?: string | ((node: Node) => boolean | void),
        root?: Node
    ): Node | null;
};

property getParents

getParents: {
    <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[];
};

property getPos

getPos: (
    elm: string | Element,
    rootElm?: Node
) => {
    x: number;
    y: number;
};

property getPrev

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

property getRect

getRect: (elm: string | HTMLElement) => GeomRect;

property getRoot

getRoot: () => HTMLElement;

property getSize

getSize: (elm: string | HTMLElement) => {
    w: number;
    h: number;
};

property getStyle

getStyle: {
    (elm: Element, name: string, computed: true): string;
    (elm: string | Element | null, name: string, computed?: boolean):
        | string
        | undefined;
};

property getViewPort

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

property hasClass

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

property hide

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

property insertAfter

insertAfter: {
    <T extends Node>(node: T | T[], reference: string | Node): T;
    <T extends Node>(node: RunArguments<T>, reference: string | Node): RunResult<
        typeof node,
        T
    >;
};

property is

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

property isBlock

isBlock: {
    (node: Node | null): node is HTMLElement;
    (node: string): boolean;
};

property isChildOf

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

property isEditable

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

property isEmpty

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

property isHidden

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

property loadCSS

loadCSS: (url: string) => void;

property nodeIndex

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

property parseStyle

parseStyle: (cssText: string) => Record<string, string>;

property remove

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

property removeAllAttribs

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

property removeClass

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

property rename

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

property replace

replace: {
    <T extends Node>(newElm: Node, oldElm: T | T[], keepChildren?: boolean): T;
    <T extends Node>(
        newElm: Node,
        oldElm: RunArguments<T>,
        keepChildren?: boolean
    ): false | T;
};

property root

root: Node | null;

property schema

schema: Schema;

property select

select: {
    <K extends keyof HTMLElementTagNameMap>(
        selector: K,
        scope?: string | Node
    ): Array<HTMLElementTagNameMap[K]>;
    <T extends HTMLElement = HTMLElement>(
        selector: string,
        scope?: string | Node
    ): T[];
};

property serializeStyle

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

property setAttrib

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

property setAttribs

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

property setHTML

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

property setOuterHTML

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

property setStyle

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

property setStyles

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

property settings

settings: Partial<DOMUtilsSettings>;

property show

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

property split

split: {
    <T extends Node>(parentElm: Node, splitElm: Node, replacementElm: T):
        | T
        | undefined;
    <T extends Node>(parentElm: Node, splitElm: T): T | undefined;
};

property stdMode

stdMode: boolean;

property styles

styles: Styles;

property styleSheetLoader

styleSheetLoader: StyleSheetLoader;

property toggleClass

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

property unbind

unbind: {
    <K extends string>(
        target: Target,
        name?: K,
        func?: EventUtilsCallback<MappedEvent<HTMLElementEventMap, K>>
    ): EventUtils;
    <K extends string>(
        target: Target[],
        name?: K,
        func?: EventUtilsCallback<MappedEvent<HTMLElementEventMap, K>>
    ): EventUtils[];
};

property uniqueId

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

property win

win: Window;

method run

run: {
    <R, T extends Node>(
        this: DOMUtils,
        elm: T | T[],
        func: (node: T) => R,
        scope?: any
    ): T | T[] extends any[] ? R[] : R;
    <R, T extends Node>(
        this: DOMUtils,
        elm: RunArguments<T>,
        func: (node: T) => R,
        scope?: any
    ): false | R | RunResult<T, R> | R[];
};

interface EditorManager

interface EditorManager extends Observable<EditorManagerEventMap> {}

property activeEditor

activeEditor: Editor | null;

property addI18n

addI18n: (code: string, item: Record<string, string>) => void;

property baseURI

baseURI: URI;

property baseURL

baseURL: string;

property defaultOptions

defaultOptions: RawEditorOptions;

property documentBaseURL

documentBaseURL: string;

property focusedEditor

focusedEditor: Editor | null;

property i18n

i18n: I18n;

property majorVersion

majorVersion: string;

property minorVersion

minorVersion: string;

property pageUid

pageUid: string;

property releaseDate

releaseDate: string;

property suffix

suffix: string;

property translate

translate: (text: Untranslated) => TranslatedString;

property triggerSave

triggerSave: () => void;

method add

add: (this: EditorManager, editor: Editor) => Editor;

method createEditor

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

method execCommand

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

method get

get: {
    (this: EditorManager): Editor[];
    (this: EditorManager, id: string | number): Editor;
};

method init

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

method overrideDefaults

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

method remove

remove: {
    (this: EditorManager): void;
    (this: EditorManager, selector: string): void;
    (this: EditorManager, editor: Editor): Editor;
};

method setActive

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

method setup

setup: (this: EditorManager) => void;

interface EditorModeApi

interface EditorModeApi {}

property activate

activate: () => void;

property deactivate

deactivate: () => void;

property editorReadOnly

editorReadOnly: boolean;

interface EditorObservable

interface EditorObservable extends Observable<EditorEventMap> {}

method bindPendingEventDelegates

bindPendingEventDelegates: (this: Editor) => void;

method toggleNativeEvent

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

method unbindAllNativeEvents

unbindAllNativeEvents: (this: Editor) => void;

interface EditorOptions

interface EditorOptions extends NormalizedEditorOptions {}

property a11y_advanced_options

a11y_advanced_options: boolean;

property allow_unsafe_link_target

allow_unsafe_link_target: boolean;

property anchor_bottom

anchor_bottom: string;

property anchor_top

anchor_top: string;

property automatic_uploads

automatic_uploads: boolean;

property block_formats

block_formats: string;

property body_class

body_class: string;

property body_id

body_id: string;

property br_newline_selector

br_newline_selector: string;

property color_cols

color_cols: number;

property color_cols_background

color_cols_background: number;

property color_cols_foreground

color_cols_foreground: number;

property color_default_background

color_default_background: string;

property color_default_foreground

color_default_foreground: string;

property color_map

color_map: string[];

property content_css

content_css: string[];

property contextmenu

contextmenu: string[];

property convert_unsafe_embeds

convert_unsafe_embeds: boolean;

property crossorigin

crossorigin: CrossOrigin;

property custom_colors

custom_colors: boolean;

property default_font_stack

default_font_stack: string[];

property disabled

disabled: boolean;

property document_base_url

document_base_url: string;

property draggable_modal

draggable_modal: boolean;

property editable_class

editable_class: string;

property editable_root

editable_root: boolean;

property font_css

font_css: string[];

property font_family_formats

font_family_formats: string;

property font_size_classes

font_size_classes: string;

property font_size_formats

font_size_formats: string;

property font_size_input_default_unit

font_size_input_default_unit: string;

property font_size_legacy_values

font_size_legacy_values: string;

property font_size_style_values

font_size_style_values: string;

property forced_root_block

forced_root_block: string;

property forced_root_block_attrs

forced_root_block_attrs: Record<string, string>;

property format_noneditable_selector

format_noneditable_selector: string;

property height

height: number | string;

property highlight_on_focus

highlight_on_focus: boolean;

property iframe_attrs

iframe_attrs: Record<string, string>;

property images_file_types

images_file_types: string;

property images_upload_base_path

images_upload_base_path: string;

property images_upload_credentials

images_upload_credentials: boolean;

property images_upload_url

images_upload_url: string;

property indent_use_margin

indent_use_margin: boolean;

property indentation

indentation: string;

property init_content_sync

init_content_sync: boolean;

property inline

inline: boolean;

property inline_boundaries_selector

inline_boundaries_selector: string;

property language

language: string;

property language_load

language_load: boolean;

property language_url

language_url: string;

property line_height_formats

line_height_formats: string;

menu: Record<
    string,
    {
        title: string;
        items: string;
    }
>;

property menubar

menubar: boolean | string;

property model

model: string;

property newdocument_content

newdocument_content: string;

property no_newline_selector

no_newline_selector: string;

property noneditable_class

noneditable_class: string;

property noneditable_regexp

noneditable_regexp: RegExp[];

property object_resizing

object_resizing: string;

property pad_empty_with_br

pad_empty_with_br: boolean;

property paste_as_text

paste_as_text: boolean;

property preview_styles

preview_styles: string;

property promotion

promotion: boolean;

property readonly

readonly: boolean;

property removed_menuitems

removed_menuitems: string;

property sandbox_iframes

sandbox_iframes: boolean;

property sandbox_iframes_exclusions

sandbox_iframes_exclusions: string[];

property text_patterns

text_patterns: Pattern[];

property text_patterns_lookup

text_patterns_lookup: DynamicPatternsLookup;

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

property toolbar_groups

toolbar_groups: Record<string, GroupToolbarButtonSpec>;

property toolbar_location

toolbar_location: ToolbarLocation;

property toolbar_mode

toolbar_mode: ToolbarMode;

property toolbar_persist

toolbar_persist: boolean;

property toolbar_sticky

toolbar_sticky: boolean;

property toolbar_sticky_offset

toolbar_sticky_offset: number;

property user_id

user_id: string;

property visual

visual: boolean;

property visual_anchor_class

visual_anchor_class: string;

property visual_table_class

visual_table_class: string;

property width

width: number | string;

property xss_sanitization

xss_sanitization: boolean;

interface EditorSelection

interface EditorSelection {}

property bookmarkManager

bookmarkManager: BookmarkManager;

property collapse

collapse: (toStart?: boolean) => void;

property controlSelection

controlSelection: ControlSelection;

property destroy

destroy: () => void;

property dom

dom: DOMUtils;

property editor

editor: Editor;

property expand

expand: (options?: { type: 'word' }) => void;

property getBookmark

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

property getBoundingClientRect

getBoundingClientRect: () => ClientRect | DOMRect;

property getContent

getContent: {
    (
        args: {
            format: 'tree';
        } & Partial<GetSelectionContentArgs>
    ): AstNode;
    (args?: Partial<GetSelectionContentArgs>): string;
};

property getEnd

getEnd: (real?: boolean) => Element;

property getNode

getNode: () => HTMLElement;

property getRng

getRng: () => Range;

property getScrollContainer

getScrollContainer: () => HTMLElement | undefined;

property getSel

getSel: () => Selection | null;

property getSelectedBlocks

getSelectedBlocks: (startElm?: Element, endElm?: Element) => Element[];

property getStart

getStart: (real?: boolean) => Element;

property isCollapsed

isCollapsed: () => boolean;

property isEditable

isEditable: () => boolean;

property isForward

isForward: () => boolean;

property moveToBookmark

moveToBookmark: (bookmark: Bookmark) => void;

property normalize

normalize: () => Range;

property placeCaretAt

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

property scrollIntoView

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

property select

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

property selectorChanged

selectorChanged: (
    selector: string,
    callback: (
        active: boolean,
        args: {
            node: Node;
            selector: String;
            parents: Node[];
        }
    ) => void
) => EditorSelection;

property selectorChangedWithUnbind

selectorChangedWithUnbind: (
    selector: string,
    callback: (
        active: boolean,
        args: {
            node: Node;
            selector: String;
            parents: Node[];
        }
    ) => void
) => {
    unbind: () => void;
};

property serializer

serializer: DomSerializer;

property setContent

setContent: (content: string, args?: Partial<SetSelectionContentArgs>) => void;

property setCursorLocation

setCursorLocation: {
    (node: Node, offset: number): void;
    (): void;
};

property setNode

setNode: (elm: Element) => Element;

property setRng

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

property win

win: Window;

interface Entities

interface Entities {}

property decode

decode: (text: string) => string;

property encodeAllRaw

encodeAllRaw: (text: string) => string;

property encodeNamed

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

property encodeNumeric

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

property encodeRaw

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

property getEncodeFunc

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

interface Env

interface Env {}

property browser

browser: {
    current: string | undefined;
    version: Version;
    isEdge: () => boolean;
    isChromium: () => boolean;
    isIE: () => boolean;
    isOpera: () => boolean;
    isFirefox: () => boolean;
    isSafari: () => boolean;
};

property cacheSuffix

cacheSuffix: any;

property canHaveCSP

canHaveCSP: boolean;

property container

container: any;

property deviceType

deviceType: {
    isiPad: () => boolean;
    isiPhone: () => boolean;
    isTablet: () => boolean;
    isPhone: () => boolean;
    isTouch: () => boolean;
    isWebView: () => boolean;
    isDesktop: () => boolean;
};

property documentMode

documentMode: number;

property os

os: {
    current: string | undefined;
    version: Version;
    isWindows: () => boolean;
    isiOS: () => boolean;
    isAndroid: () => boolean;
    isMacOS: () => boolean;
    isLinux: () => boolean;
    isSolaris: () => boolean;
    isFreeBSD: () => boolean;
    isChromeOS: () => boolean;
};

property transparentSrc

transparentSrc: string;

property windowsPhone

windowsPhone: boolean;

interface ExpectedUser

interface ExpectedUser {}

property id

id: UserId;

index signature

[key: string]: any;

interface FakeClipboard

interface FakeClipboard {}

property clear

readonly clear: () => void;

property FakeClipboardItem

readonly FakeClipboardItem: (items: Record<string, any>) => FakeClipboardItem;

property read

readonly read: () => FakeClipboardItem[] | undefined;

property write

readonly write: (data: FakeClipboardItem[]) => void;

interface FocusManager

interface FocusManager {}

property isEditorUIElement

isEditorUIElement: (elm: Element) => boolean;

interface Formatter

interface Formatter extends FormatRegistry {}

property apply

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

property canApply

canApply: (name: string) => boolean;

property closest

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

property formatChanged

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

property getCssText

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

property match

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

property matchAll

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

property matchNode

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

property remove

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

property toggle

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

interface GeomRect

interface GeomRect {}

property h

readonly h: number;

property w

readonly w: number;

property x

readonly x: number;

property y

readonly y: number;

interface HtmlSerializer

interface HtmlSerializer {}

property serialize

serialize: (node: AstNode) => string;

interface HtmlSerializerSettings

interface HtmlSerializerSettings extends WriterSettings {}

property inner

inner?: boolean;

property validate

validate?: boolean;

interface I18n

interface I18n {}

property add

add: (code: string, items: Record<string, string>) => void;

property getCode

getCode: () => string;

property getData

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

property hasCode

hasCode: (code: string) => boolean;

property isRtl

isRtl: () => boolean;

property setCode

setCode: (newCode: string) => void;

property translate

translate: (text: Untranslated) => TranslatedString;

interface IconManager

interface IconManager {}

property add

add: (id: string, iconPack: IconPack) => void;

property get

get: (id: string) => IconPack;

property has

has: (id: string) => boolean;

interface Model

interface Model {}

property table

readonly table: {
    readonly getSelectedCells: () => HTMLTableCellElement[];
    readonly clearSelectedCells: (container: Node) => void;
};

interface NotificationApi

interface NotificationApi {}

property close

close: () => void;

property getEl

getEl: () => HTMLElement;

property progressBar

progressBar: {
    value: (percent: number) => void;
};

property reposition

reposition: () => void;

property settings

settings: NotificationSpec;

property text

text: (text: string) => void;

interface NotificationManager

interface NotificationManager {}

property close

close: () => void;

property getNotifications

getNotifications: () => NotificationApi[];

property open

open: (spec: NotificationSpec) => NotificationApi;

interface NotificationSpec

interface NotificationSpec {}

property icon

icon?: string;

property progressBar

progressBar?: boolean;

property text

text: string;

property timeout

timeout?: number;

property type

type?: 'info' | 'warning' | 'error' | 'success';

interface Observable

interface Observable<T extends {}> {}

method dispatch

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

method fire

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

method hasEventListeners

hasEventListeners: (name: string) => boolean;

method off

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

method on

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

method once

once: <K extends string>(
    name: K,
    callback: (event: EditorEvent<MappedEvent<T, K>>) => void
) => EventDispatcher<T>;

interface Plugin

interface Plugin {}

property getMetadata

getMetadata?: () => {
    name: string;
    url: string;
};

property init

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

index signature

[key: string]: any;

interface RangeUtils

interface RangeUtils {}

property expand

expand: (
    rng: Range,
    options?: {
        type: 'word';
    }
) => Range;

property normalize

normalize: (rng: Range) => boolean;

property split

split: (rng: Range) => RangeLikeObject;

property walk

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

interface RawEditorOptions

interface RawEditorOptions extends BaseEditorOptions {}

property external_plugins

external_plugins?: Record<string, string>;

property mobile

mobile?: RawEditorOptions;

property plugins

plugins?: string | string[];

interface Rect

interface Rect {}

property clamp

clamp: (rect: GeomRect, clampRect: GeomRect, fixedSize?: boolean) => GeomRect;

property create

create: (x: number, y: number, w: number, h: number) => GeomRect;

property findBestRelativePosition

findBestRelativePosition: (
    rect: GeomRect,
    targetRect: GeomRect,
    constrainRect: GeomRect,
    rels: string[]
) => string | null;

property fromClientRect

fromClientRect: (clientRect: DOMRect) => GeomRect;

property inflate

inflate: (rect: GeomRect, w: number, h: number) => GeomRect;

property intersect

intersect: (rect: GeomRect, cropRect: GeomRect) => GeomRect | null;

property relativePosition

relativePosition: (
    rect: GeomRect,
    targetRect: GeomRect,
    rel: string
) => GeomRect;

interface Resource

interface Resource {}

property add

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

property get

get: (id: string) => any;

property has

has: (id: string) => boolean;

property load

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

property unload

unload: (id: string) => void;

interface Schema

interface Schema {}

property addCustomElements

addCustomElements: (
    customElements: string | Record<string, CustomElementSpec>
) => void;

property addValidChildren

addValidChildren: (validChildren: any) => void;

property addValidElements

addValidElements: (validElements: string) => void;

property children

children: Record<string, SchemaMap>;

property elements

elements: Record<string, SchemaElement>;

property getBlockElements

getBlockElements: () => SchemaMap;

property getBoolAttrs

getBoolAttrs: () => SchemaMap;

property getCustomElements

getCustomElements: () => SchemaMap;

property getElementRule

getElementRule: (name: string) => SchemaElement | undefined;

property getInvalidStyles

getInvalidStyles: () => Record<string, SchemaMap> | undefined;

property getMoveCaretBeforeOnEnterElements

getMoveCaretBeforeOnEnterElements: () => SchemaMap;

property getNonEmptyElements

getNonEmptyElements: () => SchemaMap;

property getSelfClosingElements

getSelfClosingElements: () => SchemaMap;

property getSpecialElements

getSpecialElements: () => SchemaRegExpMap;

property getTextBlockElements

getTextBlockElements: () => SchemaMap;

property getTextInlineElements

getTextInlineElements: () => SchemaMap;

property getTransparentElements

getTransparentElements: () => SchemaMap;

property getValidClasses

getValidClasses: () => Record<string, SchemaMap> | undefined;

property getValidStyles

getValidStyles: () => Record<string, string[]> | undefined;

property getVoidElements

getVoidElements: () => SchemaMap;

property getWhitespaceElements

getWhitespaceElements: () => SchemaMap;

property isBlock

isBlock: (name: string) => boolean;

property isInline

isInline: (name: string) => boolean;

property isValid

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

property isValidChild

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

property isWrapper

isWrapper: (name: string) => boolean;

property setValidElements

setValidElements: (validElements: string) => void;

property type

type: SchemaType;

interface SchemaSettings

interface SchemaSettings extends ElementSettings {}

property custom_elements

custom_elements?: string | Record<string, CustomElementSpec>;

property extended_valid_elements

extended_valid_elements?: string;

property invalid_elements

invalid_elements?: string;

property invalid_styles

invalid_styles?: string | Record<string, string>;

property padd_empty_block_inline_children

padd_empty_block_inline_children?: boolean;

property schema

schema?: SchemaType;

property valid_children

valid_children?: string;

property valid_classes

valid_classes?: string | Record<string, string>;

property valid_elements

valid_elements?: string;

property valid_styles

valid_styles?: string | Record<string, string>;

property verify_html

verify_html?: boolean;

interface Styles

interface Styles {}

property parse

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

property serialize

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

interface StyleSheetLoader

interface StyleSheetLoader {}

property load

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

property loadAll

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

property loadRawCss

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

property unload

unload: (url: string) => void;

property unloadAll

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

property unloadRawCss

unloadRawCss: (key: string) => void;

interface TextSeeker

interface TextSeeker {}

property backwards

backwards: (
    node: Node,
    offset: number,
    process: TextProcessCallback,
    root?: Node
) => Spot | null;

property forwards

forwards: (
    node: Node,
    offset: number,
    process: TextProcessCallback,
    root?: Node
) => Spot | null;

interface Theme

interface Theme {}

property destroy

destroy?: () => void;

property execCommand

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

property getNotificationManagerImpl

getNotificationManagerImpl?: () => NotificationManagerImpl;

property getPromotionElement

getPromotionElement?: () => HTMLElement | null;

property getWindowManagerImpl

getWindowManagerImpl?: () => WindowManagerImpl;

property init

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

property inline

inline?: any;

property renderUI

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

property ui

ui?: any;

interface TinyMCE

interface TinyMCE extends EditorManager {}

property AddOnManager

AddOnManager: AddOnManagerNamespace;

property Annotator

Annotator: (editor: Editor) => Annotator;

property dom

dom: {
    EventUtils: EventUtilsConstructor;
    TreeWalker: DomTreeWalkerConstructor;
    TextSeeker: (
        dom: DOMUtils,
        isBlockBoundary?: (node: Node) => boolean
    ) => TextSeeker;
    DOMUtils: DOMUtilsNamespace;
    ScriptLoader: ScriptLoaderConstructor;
    RangeUtils: RangeUtilsNamespace;
    Serializer: (
        settings: DomSerializerSettings,
        editor?: Editor
    ) => DomSerializer;
    ControlSelection: (
        selection: EditorSelection,
        editor: Editor
    ) => ControlSelection;
    BookmarkManager: BookmarkManagerNamespace;
    Selection: (
        dom: DOMUtils,
        win: Window,
        serializer: DomSerializer,
        editor: Editor
    ) => EditorSelection;
    StyleSheetLoader: (
        documentOrShadowRoot: Document | ShadowRoot,
        settings: StyleSheetLoaderSettings
    ) => StyleSheetLoader;
    Event: EventUtils;
};

property DOM

DOM: DOMUtils;

property each

each: Tools['each'];

property Editor

Editor: EditorConstructor;

property EditorCommands

EditorCommands: EditorCommandsConstructor;

property EditorManager

EditorManager: EditorManager;

property EditorObservable

EditorObservable: EditorObservable;

property Env

Env: Env;

property explode

explode: Tools['explode'];

property extend

extend: Tools['extend'];

property FakeClipboard

FakeClipboard: FakeClipboard;

property FocusManager

FocusManager: FocusManager;

property Formatter

Formatter: (editor: Editor) => Formatter;

property geom

geom: {
    Rect: Rect;
};

property grep

grep: Tools['grep'];

property html

html: {
    Styles: (settings?: StylesSettings, schema?: Schema) => Styles;
    Entities: Entities;
    Node: AstNodeConstructor;
    Schema: (settings?: SchemaSettings) => Schema;
    DomParser: (settings?: DomParserSettings, schema?: Schema) => DomParser;
    Writer: (settings?: WriterSettings) => Writer;
    Serializer: (
        settings?: HtmlSerializerSettings,
        schema?: Schema
    ) => HtmlSerializer;
};

property IconManager

IconManager: IconManager;

property inArray

inArray: Tools['inArray'];

property is

is: Tools['is'];

property isArray

isArray: Tools['isArray'];

property makeMap

makeMap: Tools['makeMap'];

property map

map: Tools['map'];

property ModelManager

ModelManager: ModelManager;

property NotificationManager

NotificationManager: (editor: Editor) => NotificationManager;

property PluginManager

PluginManager: PluginManager;

property resolve

resolve: Tools['resolve'];

property Resource

Resource: Resource;

property ScriptLoader

ScriptLoader: ScriptLoader;

property Shortcuts

Shortcuts: ShortcutsConstructor;

property ThemeManager

ThemeManager: ThemeManager;

property toArray

toArray: Tools['toArray'];

property trim

trim: Tools['trim'];

property UndoManager

UndoManager: (editor: Editor) => UndoManager;

property util

util: {
    Delay: Delay;
    Tools: Tools;
    VK: VK;
    URI: URIConstructor;
    EventDispatcher: EventDispatcherConstructor<any>;
    Observable: Observable<any>;
    I18n: I18n;
    LocalStorage: Storage;
    ImageUploader: ImageUploader;
};

property walk

walk: Tools['walk'];

property WindowManager

WindowManager: (editor: Editor) => WindowManager;

interface Tools

interface Tools {}

property each

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

property explode

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

property extend

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

property grep

grep: {
    <T>(
        arr: ArrayLike<T> | null | undefined,
        pred?: ArrayCallback<T, boolean>
    ): T[];
    <T>(
        arr: Record<string, T> | null | undefined,
        pred?: ObjCallback<T, boolean>
    ): T[];
};

property hasOwn

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

property inArray

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

property is

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

property isArray

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

property makeMap

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

property map

map: {
    <T, R>(arr: ArrayLike<T> | null | undefined, cb: ArrayCallback<T, R>): R[];
    <T, R>(
        obj: Record<string, T> | null | undefined,
        cb: ObjCallback<T, R>
    ): R[];
};

property resolve

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

property toArray

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

property trim

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

property walk

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

interface UndoManager

interface UndoManager {}

property add

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

property beforeChange

beforeChange: () => void;

property clear

clear: () => void;

property data

data: UndoLevel[];

property dispatchChange

dispatchChange: () => void;

property extra

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

property hasRedo

hasRedo: () => boolean;

property hasUndo

hasUndo: () => boolean;

property ignore

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

property redo

redo: () => UndoLevel | undefined;

property reset

reset: () => void;

property transact

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

property typing

typing: boolean;

property undo

undo: () => UndoLevel | undefined;

interface User

interface User {}

property avatar

avatar: string;

property custom

custom?: Record<string, any>;

property id

id: UserId;

property name

name: string;

interface VK

interface VK {}

property BACKSPACE

BACKSPACE: number;

property DELETE

DELETE: number;

property DOWN

DOWN: number;

property END

END: number;

property ENTER

ENTER: number;

property ESC

ESC: number;

property HOME

HOME: number;

property LEFT

LEFT: number;

property metaKeyPressed

metaKeyPressed: (e: KeyboardLikeEvent) => boolean;

property modifierPressed

modifierPressed: (e: KeyboardLikeEvent) => boolean;

property PAGE_DOWN

PAGE_DOWN: number;

property PAGE_UP

PAGE_UP: number;

property RIGHT

RIGHT: number;

property SPACEBAR

SPACEBAR: number;

property TAB

TAB: number;

property UP

UP: number;

interface WindowManager

interface WindowManager {}

property alert

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

property close

close: () => void;

property confirm

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

property open

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

property openUrl

openUrl: (config: UrlDialogSpec) => UrlDialogInstanceApi;

interface Writer

interface Writer {}

property cdata

cdata: (text: string) => void;

property comment

comment: (text: string) => void;

property doctype

doctype: (text: string) => void;

property end

end: (name: string) => void;

property getContent

getContent: () => string;

property pi

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

property reset

reset: () => void;

property start

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

property text

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

interface WriterSettings

interface WriterSettings {}

property element_format

element_format?: 'xhtml' | 'html';

property entities

entities?: string;

property entity_encoding

entity_encoding?: EntityEncoding;

property indent

indent?: boolean;

property indent_after

indent_after?: string;

property indent_before

indent_before?: string;

Type Aliases

type Bookmark

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

type EditorEvent

type EditorEvent<T> = NormalizedEvent<T>;

type ModelManager

type ModelManager = AddOnManager<Model>;

type PluginManager

type PluginManager = AddOnManager<void | Plugin>;

type ThemeManager

type ThemeManager = AddOnManager<void | Theme>;

Namespaces

namespace Events

namespace Events {}

type AddUndoEvent

type EventTypes_d_AddUndoEvent = AddUndoEvent;

type AfterProgressStateEvent

type EventTypes_d_AfterProgressStateEvent = AfterProgressStateEvent;

type BeforeGetContentEvent

type EventTypes_d_BeforeGetContentEvent = BeforeGetContentEvent;

type BeforeOpenNotificationEvent

type EventTypes_d_BeforeOpenNotificationEvent = BeforeOpenNotificationEvent;

type BeforeSetContentEvent

type EventTypes_d_BeforeSetContentEvent = BeforeSetContentEvent;

type ChangeEvent

type EventTypes_d_ChangeEvent = ChangeEvent;

type DisabledStateChangeEvent

type EventTypes_d_DisabledStateChangeEvent = DisabledStateChangeEvent;

type EditableRootStateChangeEvent

type EventTypes_d_EditableRootStateChangeEvent = EditableRootStateChangeEvent;

type EditorEventMap

type EventTypes_d_EditorEventMap = EditorEventMap;

type EditorManagerEventMap

type EventTypes_d_EditorManagerEventMap = EditorManagerEventMap;

type ExecCommandEvent

type EventTypes_d_ExecCommandEvent = ExecCommandEvent;

type FormatEvent

type EventTypes_d_FormatEvent = FormatEvent;

type GetContentEvent

type EventTypes_d_GetContentEvent = GetContentEvent;

type LoadErrorEvent

type EventTypes_d_LoadErrorEvent = LoadErrorEvent;

type NewBlockEvent

type EventTypes_d_NewBlockEvent = NewBlockEvent;

type NewTableCellEvent

type EventTypes_d_NewTableCellEvent = NewTableCellEvent;

type NewTableRowEvent

type EventTypes_d_NewTableRowEvent = NewTableRowEvent;

type NodeChangeEvent

type EventTypes_d_NodeChangeEvent = NodeChangeEvent;

type ObjectResizeEvent

type EventTypes_d_ObjectResizeEvent = ObjectResizeEvent;

type ObjectSelectedEvent

type EventTypes_d_ObjectSelectedEvent = ObjectSelectedEvent;

type OpenNotificationEvent

type EventTypes_d_OpenNotificationEvent = OpenNotificationEvent;

type PastePlainTextToggleEvent

type EventTypes_d_PastePlainTextToggleEvent = PastePlainTextToggleEvent;

type PastePostProcessEvent

type EventTypes_d_PastePostProcessEvent = PastePostProcessEvent;

type PastePreProcessEvent

type EventTypes_d_PastePreProcessEvent = PastePreProcessEvent;

type PlaceholderToggleEvent

type EventTypes_d_PlaceholderToggleEvent = PlaceholderToggleEvent;

type PostProcessEvent

type EventTypes_d_PostProcessEvent = PostProcessEvent;

type PreProcessEvent

type EventTypes_d_PreProcessEvent = PreProcessEvent;

type ProgressStateEvent

type EventTypes_d_ProgressStateEvent = ProgressStateEvent;

type SaveContentEvent

type EventTypes_d_SaveContentEvent = SaveContentEvent;

type ScrollIntoViewEvent

type EventTypes_d_ScrollIntoViewEvent = ScrollIntoViewEvent;

type SetContentEvent

type EventTypes_d_SetContentEvent = SetContentEvent;

type SetSelectionRangeEvent

type EventTypes_d_SetSelectionRangeEvent = SetSelectionRangeEvent;

type ShowCaretEvent

type EventTypes_d_ShowCaretEvent = ShowCaretEvent;

type SwitchModeEvent

type EventTypes_d_SwitchModeEvent = SwitchModeEvent;

type TableEventData

type EventTypes_d_TableEventData = TableEventData;

type TableModifiedEvent

type EventTypes_d_TableModifiedEvent = TableModifiedEvent;

type UndoRedoEvent

type EventTypes_d_UndoRedoEvent = UndoRedoEvent;

type WindowEvent

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

namespace Formats

namespace Formats {}

type ApplyFormat

type Format_d_ApplyFormat = ApplyFormat;

type BlockFormat

type Format_d_BlockFormat = BlockFormat;

type Format

type Format_d_Format = Format;

type Formats

type Format_d_Formats = Formats;

type InlineFormat

type Format_d_InlineFormat = InlineFormat;

type RemoveBlockFormat

type Format_d_RemoveBlockFormat = RemoveBlockFormat;

type RemoveFormat

type Format_d_RemoveFormat = RemoveFormat;

type RemoveInlineFormat

type Format_d_RemoveInlineFormat = RemoveInlineFormat;

type RemoveSelectorFormat

type Format_d_RemoveSelectorFormat = RemoveSelectorFormat;

type SelectorFormat

type Format_d_SelectorFormat = SelectorFormat;

namespace PublicDialog_d

namespace PublicDialog_d {}

interface TreeDirectorySpec

interface DirectorySpec extends BaseTreeItemSpec {}

property children

children: TreeItemSpec[];

property type

type: 'directory';

interface TreeLeafSpec

interface LeafSpec extends BaseTreeItemSpec {}

property type

type: 'leaf';

type AlertBannerSpec

type PublicDialog_d_AlertBannerSpec = AlertBannerSpec;

type BarSpec

type PublicDialog_d_BarSpec = BarSpec;

type BodyComponentSpec

type PublicDialog_d_BodyComponentSpec = BodyComponentSpec;

type ButtonSpec

type PublicDialog_d_ButtonSpec = ButtonSpec;

type CheckboxSpec

type PublicDialog_d_CheckboxSpec = CheckboxSpec;

type CollectionItem

type PublicDialog_d_CollectionItem = CollectionItem;

type CollectionSpec

type PublicDialog_d_CollectionSpec = CollectionSpec;

type ColorInputSpec

type PublicDialog_d_ColorInputSpec = ColorInputSpec;

type ColorPickerSpec

type PublicDialog_d_ColorPickerSpec = ColorPickerSpec;

type CustomEditorInit

type PublicDialog_d_CustomEditorInit = CustomEditorInit;

type CustomEditorInitFn

type PublicDialog_d_CustomEditorInitFn = CustomEditorInitFn;

type CustomEditorSpec

type PublicDialog_d_CustomEditorSpec = CustomEditorSpec;

type DialogActionDetails

type PublicDialog_d_DialogActionDetails = DialogActionDetails;

type DialogChangeDetails

type PublicDialog_d_DialogChangeDetails<T> = DialogChangeDetails<T>;

type DialogData

type PublicDialog_d_DialogData = DialogData;

type DialogFooterButtonSpec

type PublicDialog_d_DialogFooterButtonSpec = DialogFooterButtonSpec;

type DialogInstanceApi

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

type DialogSize

type PublicDialog_d_DialogSize = DialogSize;

type DialogSpec

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

type DialogTabChangeDetails

type PublicDialog_d_DialogTabChangeDetails = DialogTabChangeDetails;

type DropZoneSpec

type PublicDialog_d_DropZoneSpec = DropZoneSpec;

type GridSpec

type PublicDialog_d_GridSpec = GridSpec;

type HtmlPanelSpec

type PublicDialog_d_HtmlPanelSpec = HtmlPanelSpec;

type IframeSpec

type PublicDialog_d_IframeSpec = IframeSpec;

type ImagePreviewSpec

type PublicDialog_d_ImagePreviewSpec = ImagePreviewSpec;

type InputSpec

type PublicDialog_d_InputSpec = InputSpec;

type LabelSpec

type PublicDialog_d_LabelSpec = LabelSpec;

type ListBoxItemSpec

type PublicDialog_d_ListBoxItemSpec = ListBoxItemSpec;

type ListBoxNestedItemSpec

type PublicDialog_d_ListBoxNestedItemSpec = ListBoxNestedItemSpec;

type ListBoxSingleItemSpec

type PublicDialog_d_ListBoxSingleItemSpec = ListBoxSingleItemSpec;

type ListBoxSpec

type PublicDialog_d_ListBoxSpec = ListBoxSpec;

type PanelSpec

type PublicDialog_d_PanelSpec = PanelSpec;

type SelectBoxItemSpec

type PublicDialog_d_SelectBoxItemSpec = SelectBoxItemSpec;

type SelectBoxSpec

type PublicDialog_d_SelectBoxSpec = SelectBoxSpec;

type SizeInputSpec

type PublicDialog_d_SizeInputSpec = SizeInputSpec;

type SliderSpec

type PublicDialog_d_SliderSpec = SliderSpec;

type TableSpec

type PublicDialog_d_TableSpec = TableSpec;

type TabPanelSpec

type PublicDialog_d_TabPanelSpec = TabPanelSpec;

type TabSpec

type PublicDialog_d_TabSpec = TabSpec;

type TextAreaSpec

type PublicDialog_d_TextAreaSpec = TextAreaSpec;

type TreeItemSpec

type PublicDialog_d_TreeItemSpec = TreeItemSpec;

type TreeSpec

type PublicDialog_d_TreeSpec = TreeSpec;

type UrlDialogActionDetails

type PublicDialog_d_UrlDialogActionDetails = UrlDialogActionDetails;

type UrlDialogFooterButtonSpec

type PublicDialog_d_UrlDialogFooterButtonSpec = UrlDialogFooterButtonSpec;

type UrlDialogInstanceApi

type PublicDialog_d_UrlDialogInstanceApi = UrlDialogInstanceApi;

type UrlDialogMessage

type PublicDialog_d_UrlDialogMessage = UrlDialogMessage;

type UrlDialogSpec

type PublicDialog_d_UrlDialogSpec = UrlDialogSpec;

type UrlInputData

type PublicDialog_d_UrlInputData = UrlInputData;

type UrlInputSpec

type PublicDialog_d_UrlInputSpec = UrlInputSpec;

namespace PublicInlineContent_d

namespace PublicInlineContent_d {}

type AutocompleterContents

type PublicInlineContent_d_AutocompleterContents = AutocompleterContents;

type AutocompleterInstanceApi

type PublicInlineContent_d_AutocompleterInstanceApi = AutocompleterInstanceApi;

type AutocompleterItemSpec

type PublicInlineContent_d_AutocompleterItemSpec = AutocompleterItemSpec;

type AutocompleterSpec

type PublicInlineContent_d_AutocompleterSpec = AutocompleterSpec;

type ContextFormButtonInstanceApi

type PublicInlineContent_d_ContextFormButtonInstanceApi =
    ContextFormButtonInstanceApi;

type ContextFormButtonSpec

type PublicInlineContent_d_ContextFormButtonSpec<T> = ContextFormButtonSpec<T>;

type ContextFormInstanceApi

type PublicInlineContent_d_ContextFormInstanceApi<T> = ContextFormInstanceApi<T>;

type ContextFormSpec

type PublicInlineContent_d_ContextFormSpec = ContextFormSpec;

type ContextFormToggleButtonInstanceApi

type PublicInlineContent_d_ContextFormToggleButtonInstanceApi =
    ContextFormToggleButtonInstanceApi;

type ContextFormToggleButtonSpec

type PublicInlineContent_d_ContextFormToggleButtonSpec<T> =
    ContextFormToggleButtonSpec<T>;

type ContextPosition

type PublicInlineContent_d_ContextPosition = ContextPosition;

type ContextScope

type PublicInlineContent_d_ContextScope = ContextScope;

type ContextToolbarSpec

type PublicInlineContent_d_ContextToolbarSpec = ContextToolbarSpec;

type SeparatorItemSpec

type PublicInlineContent_d_SeparatorItemSpec = SeparatorItemSpec;

namespace PublicMenu_d

namespace PublicMenu_d {}

type CardContainerSpec

type PublicMenu_d_CardContainerSpec = CardContainerSpec;

type CardImageSpec

type PublicMenu_d_CardImageSpec = CardImageSpec;

type CardItemSpec

type PublicMenu_d_CardItemSpec = CardItemSpec;

type CardMenuItemInstanceApi

type PublicMenu_d_CardMenuItemInstanceApi = CardMenuItemInstanceApi;

type CardMenuItemSpec

type PublicMenu_d_CardMenuItemSpec = CardMenuItemSpec;

type CardTextSpec

type PublicMenu_d_CardTextSpec = CardTextSpec;

type ChoiceMenuItemInstanceApi

type PublicMenu_d_ChoiceMenuItemInstanceApi = ChoiceMenuItemInstanceApi;

type ChoiceMenuItemSpec

type PublicMenu_d_ChoiceMenuItemSpec = ChoiceMenuItemSpec;

type ColorSwatchMenuItemSpec

type PublicMenu_d_ColorSwatchMenuItemSpec = ColorSwatchMenuItemSpec;

type ContextMenuApi

type PublicMenu_d_ContextMenuApi = ContextMenuApi;

type ContextMenuContents

type PublicMenu_d_ContextMenuContents = ContextMenuContents;

type ContextMenuItem

type PublicMenu_d_ContextMenuItem = ContextMenuItem;

type ContextSubMenu

type PublicMenu_d_ContextSubMenu = ContextSubMenu;

type FancyMenuItemSpec

type PublicMenu_d_FancyMenuItemSpec = FancyMenuItemSpec;

type InsertTableMenuItemSpec

type PublicMenu_d_InsertTableMenuItemSpec = InsertTableMenuItemSpec;

type MenuItemInstanceApi

type PublicMenu_d_MenuItemInstanceApi = MenuItemInstanceApi;

type MenuItemSpec

type PublicMenu_d_MenuItemSpec = MenuItemSpec;

type NestedMenuItemContents

type PublicMenu_d_NestedMenuItemContents = NestedMenuItemContents;

type NestedMenuItemInstanceApi

type PublicMenu_d_NestedMenuItemInstanceApi = NestedMenuItemInstanceApi;

type NestedMenuItemSpec

type PublicMenu_d_NestedMenuItemSpec = NestedMenuItemSpec;

type SeparatorMenuItemSpec

type PublicMenu_d_SeparatorMenuItemSpec = SeparatorMenuItemSpec;

type ToggleMenuItemInstanceApi

type PublicMenu_d_ToggleMenuItemInstanceApi = ToggleMenuItemInstanceApi;

type ToggleMenuItemSpec

type PublicMenu_d_ToggleMenuItemSpec = ToggleMenuItemSpec;

namespace PublicSidebar_d

namespace PublicSidebar_d {}

type SidebarInstanceApi

type PublicSidebar_d_SidebarInstanceApi = SidebarInstanceApi;

type SidebarSpec

type PublicSidebar_d_SidebarSpec = SidebarSpec;

namespace PublicToolbar_d

namespace PublicToolbar_d {}

type GroupToolbarButtonInstanceApi

type PublicToolbar_d_GroupToolbarButtonInstanceApi = GroupToolbarButtonInstanceApi;

type GroupToolbarButtonSpec

type PublicToolbar_d_GroupToolbarButtonSpec = GroupToolbarButtonSpec;

type ToolbarButtonInstanceApi

type PublicToolbar_d_ToolbarButtonInstanceApi = ToolbarButtonInstanceApi;

type ToolbarButtonSpec

type PublicToolbar_d_ToolbarButtonSpec = ToolbarButtonSpec;

type ToolbarMenuButtonInstanceApi

type PublicToolbar_d_ToolbarMenuButtonInstanceApi = ToolbarMenuButtonInstanceApi;

type ToolbarMenuButtonSpec

type PublicToolbar_d_ToolbarMenuButtonSpec = ToolbarMenuButtonSpec;

type ToolbarSplitButtonInstanceApi

type PublicToolbar_d_ToolbarSplitButtonInstanceApi = ToolbarSplitButtonInstanceApi;

type ToolbarSplitButtonSpec

type PublicToolbar_d_ToolbarSplitButtonSpec = ToolbarSplitButtonSpec;

type ToolbarToggleButtonInstanceApi

type PublicToolbar_d_ToolbarToggleButtonInstanceApi = ToolbarToggleButtonInstanceApi;

type ToolbarToggleButtonSpec

type PublicToolbar_d_ToolbarToggleButtonSpec = ToolbarToggleButtonSpec;

namespace PublicView_d

namespace PublicView_d {}

type ViewInstanceApi

type PublicView_d_ViewInstanceApi = ViewInstanceApi;

type ViewSpec

type PublicView_d_ViewSpec = ViewSpec;

namespace TextPatterns

namespace TextPatterns {}

type BlockCmdPattern

type TextPatterns_d_BlockCmdPattern = BlockCmdPattern;

type BlockFormatPattern

type TextPatterns_d_BlockFormatPattern = BlockFormatPattern;

type BlockPattern

type TextPatterns_d_BlockPattern = BlockPattern;

type DynamicPatternContext

type TextPatterns_d_DynamicPatternContext = DynamicPatternContext;

type DynamicPatternsLookup

type TextPatterns_d_DynamicPatternsLookup = DynamicPatternsLookup;

type InlineCmdPattern

type TextPatterns_d_InlineCmdPattern = InlineCmdPattern;

type InlineFormatPattern

type TextPatterns_d_InlineFormatPattern = InlineFormatPattern;

type InlinePattern

type TextPatterns_d_InlinePattern = InlinePattern;

type Pattern

type TextPatterns_d_Pattern = Pattern;

type RawDynamicPatternsLookup

type TextPatterns_d_RawDynamicPatternsLookup = RawDynamicPatternsLookup;

type RawPattern

type TextPatterns_d_RawPattern = RawPattern;

namespace Ui

namespace Ui {}

type EditorUi

type Ui_d_EditorUi = EditorUi;

type EditorUiApi

type Ui_d_EditorUiApi = EditorUiApi;

type Registry

type Ui_d_Registry = Registry;

namespace Ui.Dialog

namespace Ui.Dialog {}

interface TreeDirectorySpec

interface DirectorySpec extends BaseTreeItemSpec {}

property children

children: TreeItemSpec[];

property type

type: 'directory';

interface TreeLeafSpec

interface LeafSpec extends BaseTreeItemSpec {}

property type

type: 'leaf';

type AlertBannerSpec

type PublicDialog_d_AlertBannerSpec = AlertBannerSpec;

type BarSpec

type PublicDialog_d_BarSpec = BarSpec;

type BodyComponentSpec

type PublicDialog_d_BodyComponentSpec = BodyComponentSpec;

type ButtonSpec

type PublicDialog_d_ButtonSpec = ButtonSpec;

type CheckboxSpec

type PublicDialog_d_CheckboxSpec = CheckboxSpec;

type CollectionItem

type PublicDialog_d_CollectionItem = CollectionItem;

type CollectionSpec

type PublicDialog_d_CollectionSpec = CollectionSpec;

type ColorInputSpec

type PublicDialog_d_ColorInputSpec = ColorInputSpec;

type ColorPickerSpec

type PublicDialog_d_ColorPickerSpec = ColorPickerSpec;

type CustomEditorInit

type PublicDialog_d_CustomEditorInit = CustomEditorInit;

type CustomEditorInitFn

type PublicDialog_d_CustomEditorInitFn = CustomEditorInitFn;

type CustomEditorSpec

type PublicDialog_d_CustomEditorSpec = CustomEditorSpec;

type DialogActionDetails

type PublicDialog_d_DialogActionDetails = DialogActionDetails;

type DialogChangeDetails

type PublicDialog_d_DialogChangeDetails<T> = DialogChangeDetails<T>;

type DialogData

type PublicDialog_d_DialogData = DialogData;

type DialogFooterButtonSpec

type PublicDialog_d_DialogFooterButtonSpec = DialogFooterButtonSpec;

type DialogInstanceApi

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

type DialogSize

type PublicDialog_d_DialogSize = DialogSize;

type DialogSpec

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

type DialogTabChangeDetails

type PublicDialog_d_DialogTabChangeDetails = DialogTabChangeDetails;

type DropZoneSpec

type PublicDialog_d_DropZoneSpec = DropZoneSpec;

type GridSpec

type PublicDialog_d_GridSpec = GridSpec;

type HtmlPanelSpec

type PublicDialog_d_HtmlPanelSpec = HtmlPanelSpec;

type IframeSpec

type PublicDialog_d_IframeSpec = IframeSpec;

type ImagePreviewSpec

type PublicDialog_d_ImagePreviewSpec = ImagePreviewSpec;

type InputSpec

type PublicDialog_d_InputSpec = InputSpec;

type LabelSpec

type PublicDialog_d_LabelSpec = LabelSpec;

type ListBoxItemSpec

type PublicDialog_d_ListBoxItemSpec = ListBoxItemSpec;

type ListBoxNestedItemSpec

type PublicDialog_d_ListBoxNestedItemSpec = ListBoxNestedItemSpec;

type ListBoxSingleItemSpec

type PublicDialog_d_ListBoxSingleItemSpec = ListBoxSingleItemSpec;

type ListBoxSpec

type PublicDialog_d_ListBoxSpec = ListBoxSpec;

type PanelSpec

type PublicDialog_d_PanelSpec = PanelSpec;

type SelectBoxItemSpec

type PublicDialog_d_SelectBoxItemSpec = SelectBoxItemSpec;

type SelectBoxSpec

type PublicDialog_d_SelectBoxSpec = SelectBoxSpec;

type SizeInputSpec

type PublicDialog_d_SizeInputSpec = SizeInputSpec;

type SliderSpec

type PublicDialog_d_SliderSpec = SliderSpec;

type TableSpec

type PublicDialog_d_TableSpec = TableSpec;

type TabPanelSpec

type PublicDialog_d_TabPanelSpec = TabPanelSpec;

type TabSpec

type PublicDialog_d_TabSpec = TabSpec;

type TextAreaSpec

type PublicDialog_d_TextAreaSpec = TextAreaSpec;

type TreeItemSpec

type PublicDialog_d_TreeItemSpec = TreeItemSpec;

type TreeSpec

type PublicDialog_d_TreeSpec = TreeSpec;

type UrlDialogActionDetails

type PublicDialog_d_UrlDialogActionDetails = UrlDialogActionDetails;

type UrlDialogFooterButtonSpec

type PublicDialog_d_UrlDialogFooterButtonSpec = UrlDialogFooterButtonSpec;

type UrlDialogInstanceApi

type PublicDialog_d_UrlDialogInstanceApi = UrlDialogInstanceApi;

type UrlDialogMessage

type PublicDialog_d_UrlDialogMessage = UrlDialogMessage;

type UrlDialogSpec

type PublicDialog_d_UrlDialogSpec = UrlDialogSpec;

type UrlInputData

type PublicDialog_d_UrlInputData = UrlInputData;

type UrlInputSpec

type PublicDialog_d_UrlInputSpec = UrlInputSpec;

namespace Ui.InlineContent

namespace Ui.InlineContent {}

type AutocompleterContents

type PublicInlineContent_d_AutocompleterContents = AutocompleterContents;

type AutocompleterInstanceApi

type PublicInlineContent_d_AutocompleterInstanceApi = AutocompleterInstanceApi;

type AutocompleterItemSpec

type PublicInlineContent_d_AutocompleterItemSpec = AutocompleterItemSpec;

type AutocompleterSpec

type PublicInlineContent_d_AutocompleterSpec = AutocompleterSpec;

type ContextFormButtonInstanceApi

type PublicInlineContent_d_ContextFormButtonInstanceApi =
    ContextFormButtonInstanceApi;

type ContextFormButtonSpec

type PublicInlineContent_d_ContextFormButtonSpec<T> = ContextFormButtonSpec<T>;

type ContextFormInstanceApi

type PublicInlineContent_d_ContextFormInstanceApi<T> = ContextFormInstanceApi<T>;

type ContextFormSpec

type PublicInlineContent_d_ContextFormSpec = ContextFormSpec;

type ContextFormToggleButtonInstanceApi

type PublicInlineContent_d_ContextFormToggleButtonInstanceApi =
    ContextFormToggleButtonInstanceApi;

type ContextFormToggleButtonSpec

type PublicInlineContent_d_ContextFormToggleButtonSpec<T> =
    ContextFormToggleButtonSpec<T>;

type ContextPosition

type PublicInlineContent_d_ContextPosition = ContextPosition;

type ContextScope

type PublicInlineContent_d_ContextScope = ContextScope;

type ContextToolbarSpec

type PublicInlineContent_d_ContextToolbarSpec = ContextToolbarSpec;

type SeparatorItemSpec

type PublicInlineContent_d_SeparatorItemSpec = SeparatorItemSpec;

namespace Ui.Menu {}

type PublicMenu_d_CardContainerSpec = CardContainerSpec;

type PublicMenu_d_CardImageSpec = CardImageSpec;

type PublicMenu_d_CardItemSpec = CardItemSpec;

type PublicMenu_d_CardMenuItemInstanceApi = CardMenuItemInstanceApi;

type PublicMenu_d_CardMenuItemSpec = CardMenuItemSpec;

type PublicMenu_d_CardTextSpec = CardTextSpec;

type PublicMenu_d_ChoiceMenuItemInstanceApi = ChoiceMenuItemInstanceApi;

type PublicMenu_d_ChoiceMenuItemSpec = ChoiceMenuItemSpec;

type PublicMenu_d_ColorSwatchMenuItemSpec = ColorSwatchMenuItemSpec;

type PublicMenu_d_ContextMenuApi = ContextMenuApi;

type PublicMenu_d_ContextMenuContents = ContextMenuContents;

type PublicMenu_d_ContextMenuItem = ContextMenuItem;

type PublicMenu_d_ContextSubMenu = ContextSubMenu;

type PublicMenu_d_FancyMenuItemSpec = FancyMenuItemSpec;

type PublicMenu_d_InsertTableMenuItemSpec = InsertTableMenuItemSpec;

type PublicMenu_d_MenuItemInstanceApi = MenuItemInstanceApi;

type PublicMenu_d_MenuItemSpec = MenuItemSpec;

type PublicMenu_d_NestedMenuItemContents = NestedMenuItemContents;

type PublicMenu_d_NestedMenuItemInstanceApi = NestedMenuItemInstanceApi;

type PublicMenu_d_NestedMenuItemSpec = NestedMenuItemSpec;

type PublicMenu_d_SeparatorMenuItemSpec = SeparatorMenuItemSpec;

type PublicMenu_d_ToggleMenuItemInstanceApi = ToggleMenuItemInstanceApi;

type PublicMenu_d_ToggleMenuItemSpec = ToggleMenuItemSpec;

namespace Ui.Sidebar {}

type PublicSidebar_d_SidebarInstanceApi = SidebarInstanceApi;

type PublicSidebar_d_SidebarSpec = SidebarSpec;

namespace Ui.Toolbar {}

type PublicToolbar_d_GroupToolbarButtonInstanceApi = GroupToolbarButtonInstanceApi;

type PublicToolbar_d_GroupToolbarButtonSpec = GroupToolbarButtonSpec;

type PublicToolbar_d_ToolbarButtonInstanceApi = ToolbarButtonInstanceApi;

type PublicToolbar_d_ToolbarButtonSpec = ToolbarButtonSpec;

type PublicToolbar_d_ToolbarMenuButtonInstanceApi = ToolbarMenuButtonInstanceApi;

type PublicToolbar_d_ToolbarMenuButtonSpec = ToolbarMenuButtonSpec;

type PublicToolbar_d_ToolbarSplitButtonInstanceApi = ToolbarSplitButtonInstanceApi;

type PublicToolbar_d_ToolbarSplitButtonSpec = ToolbarSplitButtonSpec;

type PublicToolbar_d_ToolbarToggleButtonInstanceApi = ToolbarToggleButtonInstanceApi;

type PublicToolbar_d_ToolbarToggleButtonSpec = ToolbarToggleButtonSpec;

namespace Ui.View

namespace Ui.View {}

type ViewInstanceApi

type PublicView_d_ViewInstanceApi = ViewInstanceApi;

type ViewSpec

type PublicView_d_ViewSpec = ViewSpec;

Package Files (1)

tinymce.d.ts

Dependencies (0)

No dependencies.

Dev Dependencies (0)

No dev dependencies.

Peer Dependencies (0)

No peer dependencies.

Badge

To add a badge like this oneto your package's README, use the codes available below.

You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/tinymce.

Markdown

[![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/tinymce)

HTML

<a href="https://www.jsdocs.io/package/tinymce"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>

Updated 6 days ago.
Package analyzed in 13196 ms.
Missing or incorrect documentation? Open an issue for this package.