@types/ckeditor
Version:
TypeScript definitions for CKEditor
1,226 lines (1,122 loc) • 111 kB
TypeScript
// Type definitions for CKEditor 4.9
// Project: https://ckeditor.com/ckeditor-4/, http://ckeditor.com
// Definitions by: Thomas Wittwer <https://github.com/wittwert>
// Stuart Long <https://github.com/stuartlong>
// Viktor Pegy <https://github.com/viktorpegy>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// WORK-IN-PROGRESS: Any contribution support welcomed.
// See https://github.com/DefinitelyTyped/DefinitelyTyped/issues/1827 for more informations.
interface Window {
CKEDITOR_BASEPATH?: string;
}
declare namespace CKEDITOR {
// Config options
var disableAutoInline: boolean;
var replaceClass: string;
var skinName: string;
// Properties
const ALT: number;
const CTRL: number;
const DATA_TRANSFER_CROSS_EDITORS: number;
const DATA_TRANSFER_EXTERNAL: number;
const DATA_TRANSFER_INTERNAL: number;
const DIALOG_RESIZE_BOTH: number;
const DIALOG_RESIZE_HEIGHT: number;
const DIALOG_RESIZE_NONE: number;
const DIALOG_RESIZE_WIDTH: number;
const DIALOG_STATE_BUSY: number;
const DIALOG_STATE_IDLE: number;
const ELEMENT_MODE_APPENDTO: number;
const ELEMENT_MODE_INLINE: number;
const ELEMENT_MODE_NONE: number;
const ELEMENT_MODE_REPLACE: number;
const END: number;
const ENLARGE_BLOCK_CONTENTS: number;
const ENLARGE_ELEMENT: number;
const ENLARGE_INLINE: number;
const ENLARGE_LIST_ITEM_CONTENTS: number;
const ENTER_BR: number;
const ENTER_DIV: number;
const ENTER_P: number;
const EVENT_PHASE_AT_TARGET: number;
const EVENT_PHASE_BUBBLING: number;
const EVENT_PHASE_CAPTURING: number;
const FILTER_SKIP_TREE: number;
const LINEUTILS_AFTER: number;
const LINEUTILS_BEFORE: number;
const LINEUTIS_INSIDE: number;
const MOUSE_BUTTON_LEFT: number;
const MOUSE_BUTTON_MIDDLE: number;
const MOUSE_BUTTON_RIGHT: number;
const NODE_COMMENT: number;
const NODE_DOCUMENT: number;
const NODE_DOCUMENT_FRAGMENT: number;
const NODE_ELEMENT: number;
const NODE_TEXT: number;
const POSITION_AFTER_END: number;
const POSITION_AFTER_START: number;
const POSITION_BEFORE_END: number;
const POSITION_BEFORE_START: number;
const POSITION_CONTAINS: number;
const POSITION_DISCONNECTED: number;
const POSITION_FOLLOWING: number;
const POSITION_IDENTICAL: number;
const POSITION_IS_CONTAINED: number;
const POSITION_PRECEDING: number;
const SELECTION_ELEMENT: number;
const SELECTION_NONE: number;
const SELECTION_TEXT: number;
const SHIFT: number;
const SHRINK_ELEMENT: number;
const SHRINK_TEXT: number;
const START: number;
const STYLE_BLOCK: string;
const STYLE_INLINE: string;
const STYLE_OBJECT: string;
const TRISTATE_DISABLED: number;
const TRISTATE_OFF: number;
const TRISTATE_ON: number;
const UI_BUTTON: string;
const UI_MENUBUTTON: string;
const UI_PANEL: string;
const UI_PANELBUTTON: string;
const UI_RICHCOMBO: string;
const UI_SEPARATOR: string;
const VERBOSITY_ERROR: number;
const VERBOSITY_WARN: number;
var basePath: string;
var currentInstance: editor;
var document: dom.document;
var instances: { [id: string]: editor };
var loadFullCoreTimeout: number;
var revision: string;
var rnd: number;
var status: string;
var timestamp: string;
var verbosity: number;
var version: string;
const config: config;
// Methods
function add(editor: editor): void;
function addCss(css: string): void;
function addTemplate(name: string, source: string): template;
function appendTo(element: string | HTMLElement, config?: config, data?: string): editor;
function domReady(): void;
function editorConfig(config: config): void;
function error(errorCode: string, additionalData?: any): void;
function getCss(): string;
function getTemplate(name: string): template;
function getUrl(resource: string): string;
function inline(element: string | HTMLElement, instanceConfig?: config): editor;
function inlineAll(): void;
function loadFullCore(): void;
function replace(element: string | HTMLTextAreaElement, config?: config): editor;
function replaceAll(className?: string): void;
function replaceAll(assertionFunction: (textarea: HTMLTextAreaElement, config: config) => boolean): void;
function warn(errorCode: string, additionalData?: any): void;
// Event interface
function capture(): void;
function define(name: string, meta: { [key: string]: any }): void;
function fire(eventName: string, data?: { [key: string]: any }, editor?: editor): any;
function fireOnce(eventName: string, data?: { [key: string]: any }, editor?: editor): any;
function hasListeners(eventName: string): boolean;
function on(eventName: string, listenerFunction: (eventInfo: eventInfo) => void, scopeObj?: { [key: string]: any }, listenerData?: { [key: string]: any }, priority?: number): void;
function once(eventName: string, listenerFunction: (eventInfo: eventInfo) => void, scopeObj?: { [key: string]: any }, listenerData?: { [key: string]: any }, priority?: number): void;
function removeAllListeners(): void;
function removeListener(eventName: string, listenerFunction: (eventInfo: eventInfo) => void): void;
interface listenerRegistration {
removeListener: () => void;
}
namespace dom {
interface bookmark {
startNode: dom.node | string;
endNode: dom.node | string;
serializable: boolean;
collapsed: boolean;
}
interface bookmark2 {
start: number[];
end: number[];
startOffset: number;
endOffset: number;
collapsed: boolean;
normalized: boolean;
is2: boolean;
}
class comment extends node {
readonly type: number;
constructor(comment: string | Node, ownerDocument?: document);
getOuterHtml(): string;
}
class document extends domObject {
readonly $: Document;
readonly type: number;
constructor(domDocument: { [key: string]: any });
appendStyleSheet(cssFileUrl: string): void;
appendStyleText(cssStyleText: string): CSSStyleSheet;
createElement(name: string, attribsAndStyles?: { attributes?: { [key: string]: string }; styles?: { [key: string]: string }; }): element;
createText(text: string): element;
find(selector: string): nodeList;
findOne(selector: string): element;
focus(): void;
getActive(): element;
getBody(): element;
getByAddress(address: any[], normalized?: boolean): node;
getById(elementId: string): element;
getDocumentElement(): element;
getElementsByTag(tagName: string): nodeList;
getHead(): element;
getSelection(): selection;
getWindow(): window;
write(html: string): void;
}
class documentFragment extends node {
readonly type: number;
constructor(nodeOrDoc: { [key: string]: any });
insertAfterNode(node: node): void;
}
class domObject extends CKEDITOR.event {
readonly $: any;
constructor(nativeDomObject: { [key: string]: any });
clearCustomData(): void;
equals(object: any): boolean;
getCustomData(key: string): any;
getPrivate(): any;
getUniqueId(): number;
removeAllListeners(): void;
removeCustomData(key: string): any;
setCustomData(key: string, value: any): domObject;
}
class element extends node {
readonly $: HTMLElement;
readonly type: number;
constructor(element: string | HTMLElement, ownerDocument?: document);
addClass(className: string): void;
append(node: node | string, toStart?: boolean): node;
appendBogus(force: boolean): void;
appendHtml(html: string): void;
appendText(text: string): node;
breakParent(parent: element): void;
contains(node: node): boolean;
copyAttributes(dest: element, skipAttributes: { [key: string]: string }): void;
data(name: string, value?: string | false): string;
disableContextMenu(): void;
find(selector: string): nodeList;
findOne(selector: string): element;
focus(defer?: boolean): void;
focusNext(ignoreChildren?: boolean, indexToUse?: number): void;
focusPrevious(ignoreChildren?: boolean, indexToUse?: number): void;
forEach(callback: (node: node) => void, type?: number, skipRoot?: boolean): void;
getAttribute(name: string): string;
getBogus(): node | boolean;
getChild(indices: number | number[]): node;
getChildCount(): number;
getChildren(): nodeList;
getClientRect(): ClientRect;
getComputedStyle(propertyName: string): string;
getDirection(useComputed: boolean): string;
getDocumentPosition(refDocument: document): position;
getDtd(): dtdDefinition;
getEditor(): editor;
getElementsByTag(tagName: string): nodeList;
getFirst(evaluator?: (node: node) => boolean): node;
getFrameDocument(): document;
getHtml(): string;
getId(): string;
getLast(evaluator?: (node: node) => boolean): node;
getName(): string;
getNameAtt(): string;
getOuterHtml(): string;
getPositionedAncestor(): element;
getSize(type: string, isBorderBox: boolean): void;
getStyle(name: string): string;
getTabIndex(): number;
getText(): string;
getValue(): string;
getWindow(): window;
hasAttributes(): boolean;
hasAttribute(name: string): boolean;
hasClass(className: string): boolean;
hide(): void;
is(...name: string[]): boolean;
is(name: any): boolean;
isBlockBoundary(customNodeNames: { [tagName: string]: 1 }): boolean;
isEditable(textCursor?: boolean): boolean;
isEmptyInlineRemoveable(): boolean;
isIdentical(otherElement: element): boolean;
isVisible(): boolean;
mergeSiblings(inlineOnly?: boolean): void;
moveChildren(target: element, toStart?: boolean): void;
removeAttribute(name: string): void;
removeAttributes(attributes?: string[]): void;
removeClass(className: string): void;
removeStyle(name: string): void;
renameNode(newTag: string): void;
scrollIntoParent(parent: element | window, alignToTop: boolean, hscroll: boolean): void;
scrollIntoView(alignToTop?: boolean): void;
setAttribute(name: string, value: string): element;
setAttributes(attributesPairs: { [key: string]: string }): element;
setHtml(html: string): string;
setOpacity(opacity: number): void;
setSize(type: string, size: number, isBorderBox: boolean): void;
setState(state: number, base?: string, useAria?: boolean): void;
setStyle(name: string, value: string): element;
setStyles(stylesPair: { [key: string]: string }): element;
setText(text: string): string;
setValue(value: string): element;
show(): void;
unselectable(): void;
// static method
static clearAllMarkers(database: any): any;
static clearMarkers(database: any, element: dom.element, removeFromDatabase: boolean): void;
static createFromHtml(html: string): element;
static get(element: string | HTMLElement | element): element;
static setMarker(database: any, element: dom.element, name: string, value: any): dom.element;
}
class elementPath {
readonly block: element;
readonly blockLimit: element;
readonly elements: element[];
readonly lastElement: element;
readonly root: element;
constructor(startNode: element, root?: element);
compare(otherPath: elementPath): boolean;
contains(query: string | string[] | ((element: element) => boolean) | { [key: string]: any } | element, excludeRoot?: boolean, fromTop?: boolean): element;
direction(): 'ltr' | 'rtl';
isContextFor(tag: string): boolean;
}
class event {
constructor(domEvent: Event);
getKey(): number;
getKeystroke(): number;
preventDefault(stopPropagation?: boolean): void;
stopPropagation(): void;
getTarget(): node;
getPhase(): number;
getPhaseOffset(): position;
on(eventName: string, listenerFunction: (eventInfo: eventInfo) => void, scopeObj?: any, listenerData?: any, priority?: number): { removeListener: () => void };
}
class iterator {
readonly activeFilter: filter;
enforceRealBlocks: boolean;
enlargeBr: boolean;
readonly filter: filter;
forceBrBreak: boolean;
readonly range: range;
constructor(range: range);
getNextParagraph(blockTag?: string): element;
}
class node extends domObject {
type: number;
constructor(domNode: Node);
appendTo(element: element): element;
clone(includeChildren: boolean, cloneId: boolean): node;
hasPrevious(): boolean;
hasNext(): boolean;
insertAfter(node: node): node;
insertBefore(node: node): node;
insertBeforeMe(node: node): node;
getAddress(normalized?: boolean): number[];
getAscendant(reference: string, includeSelf?: boolean): node;
getCommonAncestor(node: node): void;
getDocument(): document;
getIndex(normalized?: boolean): number;
getNext(evaluator?: (node: node) => boolean): node;
getNextSourceNode(startFromSibling?: boolean, nodeType?: number, guard?: node | ((node: node) => boolean)): node;
getParent(allowFragmentParent?: boolean): element;
getParents(closerFirst?: boolean): node[];
getPosition(otherNode: node): void;
getPrevious(evaluator?: (node: node) => boolean): node;
getPreviousSourceNode(startFromSibling?: boolean, nodeType?: number, guard?: node | ((node: node) => boolean)): node;
hasAscendant(name: string, includeSelf: boolean): boolean;
remove(preserveChildren?: boolean): node;
replace(nodeToReplace: node): void;
trim(): void;
ltrim(): void;
rtrim(): void;
isReadOnly(): boolean;
}
class nodeList {
constructor(nativeList: NodeList);
count(): number;
getItem(index: number): node;
toArray(): node[];
}
class range {
readonly collapsed: boolean;
readonly document: document;
readonly endContainer: element | text;
readonly endOffset: number;
readonly root: element;
readonly startContainer: element | text;
readonly startOffset: number;
constructor(root: element | document);
checkBoundaryOfElement(element: element, checkType: number): boolean;
checkEndOfBlock(): boolean;
checkReadOnly(): boolean;
checkStartOfBlock(): boolean;
clone(cloneId?: boolean): range;
cloneContents(): documentFragment;
collapse(toStart?: boolean): boolean;
createBookmark(serializable?: boolean): bookmark;
createBookmark2(normalized?: boolean): bookmark2;
createIterator(): iterator;
deleteContents(mergeThen?: boolean): void;
endPath(): elementPath;
enlarge(unit: number, excludeBrs?: boolean): void;
extractContents(mergeThen?: boolean, cloneId?: boolean): documentFragment;
fixBlock(isStart: boolean, blockTag: string): element;
getBoundaryNodes(): { startNode: node; endNode: node; };
getCommonAncestor(includeSelf?: boolean, ignoreTextNode?: boolean): element;
getEnclosedNode(): node;
getNextEditableNode(): element | text;
getNextNode(evaluator?: (element: dom.element) => boolean, guard?: (element: dom.element) => boolean, boundary?: element): element;
getPreviousEditableNode(): element | text;
getPreviousNode(evaluator?: (element: dom.element) => boolean, guard?: (element: dom.element) => boolean, boundary?: element): element;
getTouchedEndNode(): node;
getTouchedStartNode(): node;
insertNode(node: node): void;
moveToBookmark(bookmark: bookmark | bookmark2): void;
moveToClosestEditablePosition(element?: element, isMoveForward?: boolean): boolean;
moveToElementEditEnd(target: element): boolean;
moveToElementEditStart(target: element): boolean;
moveToElementEditablePosition(element: element, isMoveToEnd: boolean): boolean;
moveToPosition(node: node, position: number): void;
moveToRange(range: range): void;
optimize(): void;
optimizeBookmark(): void;
removeEmptyBlocksAtEnd(atEnd: boolean): void;
scrollIntoView(): void;
select(): selection;
selectNodeContents(node: node): void;
setEnd(endNode: node, endOffset: number): void;
setEndAfter(node: node): void;
setEndAt(node: node, position: number): void;
setEndBefore(node: node): void;
setStart(startNode: node, startOffset: number): void;
setStartAfter(node: node): void;
setStartAt(node: node, position: number): void;
setStartBefore(node: node): void;
shrink(mode: number, selectContents?: boolean, options?: boolean | shrinkOptions): void;
splitBlock(cloneId?: boolean): void;
splitElement(toSplit: element, cloneId?: boolean): element;
startPath(): elementPath;
trim(ignoreStart?: boolean, ignoreEnd?: boolean): void;
static mergeRanges(ranges: range[]): range[];
}
interface shrinkOptions {
shrinkOnBlockBoundary?: boolean;
skipBogus?: boolean;
}
class rangeList {
constructor(ranges?: range | range[]);
createBokmarks(serializable?: boolean): bookmark[];
createBookmarks2(normalized?: boolean): bookmark2[];
createIterator(): rangeListIterator;
moveToBookmarks(bookmarks: bookmark[]): void;
}
interface rangeListIterator {
getNextRange(mergeConsequent?: boolean): range;
}
// see https://docs.com/ckeditor4/latest/api/CKEDITOR_dom_selection.html
class selection {
readonly FILLING_CHAR_SEQUENCE: string;
readonly document: document;
readonly isFake: boolean;
readonly isLocked: boolean;
readonly rev: number;
readonly root: element;
constructor(target: document | element | selection);
createBookmarks(serializable: any): bookmark[];
createBookmarks2(normalized: any): bookmark2[];
fake(element: element, ariaLabel?: boolean): void;
getCommonAncestor(): element;
getNative(): Selection;
getRanges(onlyEditables?: boolean): range[];
getSelectedElement(): element;
getSelectedText(): string;
getStartElement(): element;
getType(): number;
isCollapsed(): boolean;
isHidden(): boolean;
isInTable(allowPartialSelection?: boolean): boolean;
lock(): void;
removeAllRanges(): void;
reset(): void;
scrollIntoView(): void;
selectBookmarks(bookmarks: Array<bookmark | bookmark2>): selection;
selectElement(element: element): void;
selectRanges(ranges: range[]): void;
unlock(restore: boolean): void;
}
class text extends node {
readonly $: Text;
readonly type: number;
constructor(text: Text | string, ownerDocument?: document);
getLength(): number;
getText(): string;
setText(text: string): void;
split(offset: number): text;
substring(indexA: number, indexB?: number): void;
}
class walker {
evaluator: (node: node) => boolean;
guard: (node: node, movingOut?: boolean) => boolean;
static validEmptyBlockContainers: { [key: string]: any };
constructor(range: range);
checkBackward(): boolean;
checkForward(): boolean;
end(): void;
lastBackward(): node;
lastForward(): node;
next(): node;
previous(): node;
reset(): void;
static blockBoundary(customNodeNames: any): (node: node) => boolean;
static bogus(isReject?: boolean): (node: node) => boolean;
static bookmark(contentOnly?: boolean, isReject?: boolean): (node: node) => boolean;
static editable(isReject?: boolean): (node: node) => boolean;
static empty(isReject?: boolean): (node: node) => boolean;
static ignored(isReject?: boolean): (node: node) => boolean;
static invisible(isReject?: boolean): (node: node) => boolean;
static listItemBoundary(): (node: node) => boolean;
static nodeType(type: number, isReject?: boolean): (node: node) => boolean;
static temp(isReject?: boolean): (node: node) => boolean;
static whitespaces(isReject?: boolean): (node: node) => boolean;
}
interface position {
x: number;
y: number;
}
interface widthAndHeight {
width: number;
height: number;
}
class window extends domObject {
constructor(domWindow: Window);
focus(): void;
getViewPaneSize(): widthAndHeight;
getScrollPosition(): position;
getFrame(): element;
}
}
namespace ajax {
function load(url: string, callback?: (data: any) => void): string;
function loadXml(url: string, callback?: (data: any) => void): xml;
function post(url: string, data: any, contentType?: string, callback?: (data: any) => void): void;
}
class command extends event implements commandDefinition {
fakeKeystroke: number;
previousState: number;
state: number;
uiItems: any[];
// Methods
constructor(editor: editor, commandDefinition: commandDefinition);
checkAllowed(noCache: boolean): boolean;
disable(): void;
enable(): void;
exec(data?: { [key: string]: any }): boolean;
refresh(editor: editor, path: dom.elementPath): void;
setState(newState: number): boolean;
toggleState(): void;
}
interface commandDefinition {
async?: boolean;
canUndo?: boolean;
context?: boolean;
contextSensitive?: boolean;
editorFocus?: boolean;
fakeKeystroke?: number;
modes?: { [key: string]: any };
startDisabled?: boolean;
readOnly?: boolean;
exec(editor: editor, data?: any): boolean;
refresh?(editor: editor, path: dom.elementPath): void;
}
// https://docs.com/ckeditor4/latest/api/CKEDITOR_config.html
interface config {
allowedContent?: boolean | filter.allowedContentRules;
autoEmbed_widget?: string | ((url: string) => string);
autoGrow_bottomSpace?: number;
autoGrow_maxHeight?: number;
autoGrow_minHeight?: number;
autoGrow_onStartup?: boolean;
autoUpdateElement?: boolean;
baseFloatZIndex?: number;
baseHref?: string;
basicEntities?: boolean;
blockedKeystrokes?: number[];
bodyClass?: string;
bodyId?: string;
browserContextMenuOnCtrl?: boolean;
clipboard_defaultContentType?: 'html' | 'text';
clipboard_notificationDuration?: number;
cloudServices_tokenUrl?: string;
cloudServices_uploadUrl?: string;
codeSnippetGeshi_url?: string;
codeSnippet_codeClass?: string;
codeSnippet_languages?: { [key: string]: any };
coceSnippet_theme?: string;
colorButton_backStyle?: config.styleObject;
colorButton_colors?: string;
colorButton_colorsPerRow?: number;
colorButton_enableAutomatic?: boolean;
colorButton_enableMore?: boolean;
colorButton_foreStyle?: config.styleObject;
colorButton_normalizeBackground?: boolean;
contentsCss?: string | string[];
contentsLangDirection?: string;
contentsLanguage?: string;
copyFormatting_allowRules?: string;
copyFormatting_allowedContexts?: boolean | string[];
copyFormatting_keystrokeCopy?: number;
copyFormatting_keystrokePaste?: number;
copyFormatting_outerCursor?: boolean;
coreStyles_bold?: config.styleObject;
coreStyles_italic?: config.styleObject;
coreStyles_strike?: config.styleObject;
coreStyles_subscript?: config.styleObject;
coreStyles_superscript?: config.styleObject;
coreStyles_underline?: config.styleObject;
customConfig?: string;
dataIndentationChars?: string;
defaultLanguage?: string;
devtools_styles?: string;
devtools_textCallback?: (editor: editor, dialog: dialog, element: dom.element, tabName: string) => string;
dialog_backgroundCoverColor?: string;
dialog_backgroundCoverOpacity?: number;
dialog_buttonsOrder?: string;
dialog_magnetDistance?: number;
dialog_noConfirmCancel?: boolean;
dialog_startupFocusTab?: boolean;
disableNativeSpellChecker?: boolean;
disableNativeTableHandles?: boolean;
disableNativeObjectResizing?: boolean;
disableNativeReadonlyStyling?: boolean;
disallowedContent?: filter.disallowedContentRules;
div_wrapTable?: boolean;
docType?: string;
easyimage_class?: string;
easyimage_defaultStyle?: string;
easyimage_styles?: { [key: string]: any };
easyimage_toolbar?: string[] | string;
emailProtection?: string;
embed_provider?: string;
emoji_emojiListUrl?: string;
emoji_minChars?: number;
enableContextMenu?: boolean;
enableTabKeyTools?: boolean;
enterMode?: number;
entities?: boolean;
entities_additional?: string;
entities_greek?: boolean;
entities_latin?: boolean;
entities_processNumerical?: boolean | string;
extraAllowedContent?: filter.allowedContentRules;
extraPlugins?: string;
fileTools_defaultFileName?: string;
fileTools_requestHeaders?: { [key: string]: any };
filebrowserBrowseUrl?: string;
filebrowserFlashBrowseUrl?: string;
filebrowserFlashUploadUrl?: string;
filebrowserImageBrowseLinkUrl?: string;
filebrowserImageBrowseUrl?: string;
filebrowserImageUploadUrl?: string;
filebrowserUploadMethod?: string;
filebrowserUploadUrl?: string;
filebrowserWindowFeatures?: string;
filebrowserWindowHeight?: number | string;
filebrowserWindowWidth?: number | string;
fillEmptyBlocks?: boolean | ((element: htmlParser.element) => boolean);
find_highlight?: config.styleObject;
flashAddEmbedTag?: boolean;
flashConvertOnEdit?: boolean;
flashEmbedTagOnly?: boolean;
floatSpaceDockedOffsetX?: number;
floatSpaceDockedOffsetY?: number;
floatSpacePinnedOffsetX?: number;
floatSpacePinnedOffsetY?: number;
floatSpacePreferRight?: boolean;
fontSize_defaultLabel?: string;
fontSize_sizes?: string;
fontSize_style?: config.styleObject;
font_defaultLabel?: string;
font_names?: string;
font_style?: config.styleObject;
forceEnterMode?: boolean;
forcePasteAsPlainText?: boolean;
forceSimpleAmpersand?: boolean;
format_address?: config.styleObject;
format_div?: config.styleObject;
format_h1?: config.styleObject;
format_h2?: config.styleObject;
format_h3?: config.styleObject;
format_h4?: config.styleObject;
format_h5?: config.styleObject;
format_h6?: config.styleObject;
format_p?: config.styleObject;
format_pre?: config.styleObject;
format_tags?: string;
fullPage?: boolean;
grayt_autoStartup?: boolean;
height?: string | number;
htmlEncodeOutput?: boolean;
ignoreEmptyParagraph?: boolean;
image2_alignClasses?: string[];
image2_altRequired?: boolean;
image2_captionedClass?: string;
image2_disableResizer?: boolean;
image2_prefillDimensions?: boolean;
imageUploadUrl?: string;
image_prefillDimensions?: boolean;
image_previewText?: string;
image_removeLinkByEmptyUrl?: boolean;
indentClasses?: string[];
indentOffset?: number;
indentUnit?: string;
jqueryOverrideVal?: boolean;
justifyClasses?: string[];
keystrokes?: Array<[number, string]>;
language?: string;
language_list?: string[];
linkJavaScriptLinksAllowed?: boolean;
linkShowAdvancedTab?: boolean;
linkShowTargetTab?: boolean;
magicline_color?: string;
magicline_everywhere?: boolean;
magicline_holdDistance?: number;
magicline_keystrokeNext?: number;
magicline_keystrokePrevious?: number;
magicline_tabuList?: string[];
magicline_triggerOffset?: number;
mathJaxClass?: string;
mathJaxLib?: string;
menu_groups?: string;
menu_subMenuDelay?: number;
newpage_html?: string;
notification_duration?: number;
on?: editor.eventObject;
pasteFilter?: string;
pasteFromWordCleanupFile?: string;
pasteFromWordNumberedHeadingToList?: boolean;
pasteFromWordPromptCleanup?: boolean;
pasteFromWordRemoveFontStyles?: boolean;
pasteFromWordRemoveStyles?: boolean;
pasteFromWord_heuristicsEdgeList?: boolean;
pasteFromWord_inlineImages?: boolean;
plugins?: string;
protectedSource?: RegExp[];
readOnly?: boolean;
removeButtons?: string;
removeDialogTabs?: string;
removeFormatAttributes?: string;
removeFormatTags?: string;
removePlugins?: string;
resize_dir?: string;
resize_enabled?: boolean;
resize_maxHeight?: number;
resize_maxWidth?: number;
resize_minHeight?: number;
resize_minWidth?: number;
scayt_autoStartup?: boolean;
scayt_contextCommands?: string;
scayt_contextMenuItemsOrder?: string;
scayt_customDictionaryIds?: string;
scayt_customerId?: string;
scayt_disableOptionsStorage?: string | string[];
scayt_elementsToIgnore?: string;
scayt_handleCheckDirty?: string;
scayt_handleUndoRedo?: string;
scayt_ignoreAllCapsWords?: boolean;
scayt_ignoreDomainNames?: boolean;
scayt_ignoreWordsWithMixedCases?: boolean;
scayt_ignoreWordsWithNumbers?: boolean;
scayt_inlineModeImmediateMarkup?: boolean;
scayt_maxSuggestions?: number;
scayt_minWordLength?: number;
scayt_moreSuggestions?: string;
scayt_multiLanguageMode?: boolean;
scayt_multiLanguageStyles?: { [key: string]: any };
scayt_sLang?: string;
scayt_serviceHost?: string;
scayt_servicePath?: string;
scayt_servicePort?: string;
scayt_serviceProtocol?: string;
scayt_srcUrl?: string;
scayt_uiTabs?: string;
scayt_userDictionaryName?: string;
sharedSpaces?: sharedSpace;
shiftEnterMode?: number;
skin?: string;
smiley_columns?: number;
smiley_descriptions?: string[];
smiley_images?: string[];
smiley_path?: string;
sourceAreaTabSize?: number;
specialChars?: Array<string | [string, string]>;
startupFocus?: string | boolean;
startupMode?: string;
startupOutlineBlocks?: boolean;
startupShowBorders?: boolean;
stylesSet?: string | boolean | config.styleObject[];
stylesheetParser_skipSelectors?: RegExp;
stylesheetParser_validSelectors?: RegExp;
tabIndex?: number;
tabSpaces?: number;
templates?: string;
templates_files?: { [key: string]: any };
templates_replaceContent?: boolean;
title?: string | boolean;
toolbar?: string | Array<string | string[] | { name: string, items?: string[], groups?: string[] }> | null;
toolbarCanCollapse?: boolean;
toolbarGroupCycling?: boolean;
toolbarGroups?: Array<toolbarGroups | string>;
toolbarLocation?: string;
toolbarStartupExpanded?: boolean;
uiColor?: string;
undoStackSize?: number;
uploadUrl?: string;
useComputedState?: boolean;
width?: string | number;
wsc_cmd?: string;
wsc_customDictionaryIds?: string;
wsc_customLoaderScript?: string;
wsc_customerId?: string;
wsc_height?: string;
wsc_lang?: string;
wsc_left?: string;
wsc_top?: string;
wsc_userDictionaryName?: string;
wsc_width?: string;
}
interface dataProcessor {
toDataFormat(html: string, fixForBody: string): void;
toHtml(data: string, fixForBody?: string): void;
}
class dialog {
readonly state: number;
constructor(editor: editor, dialogName: string);
addFocusable(element: dom.element, index?: number): void;
addPage(contents: { [key: string]: any }): void;
click(id: string): any;
commitContent(): void;
disableButton(id: string): void;
enableButton(id: string): void;
foreach(fn: () => void): dialog;
getButton(id: string): ui.dialog.button;
getContentElement(pageId: string, elementId: string): ui.dialog.uiElement;
getElement(): dom.element;
getName(): string;
getPageCount(): number;
getParentEditor(): editor;
getPosition(): { [key: string]: any };
getSelectedElement(): dom.element;
getSize(): { [key: string]: any };
getValueOf(pageId: string, elementId: string): any;
hide(): void;
hidePage(id: string): void;
layout(): void;
move(x: number, y: number, save: boolean): void;
reset(): dialog;
resize(width: number, height: number): void;
selectPage(id: string): void;
setState(state: number): void;
setValueOf(pageId: string, elementId: string, value: any): void;
setupContent(): void;
show(): void;
showPage(id: string): void;
updateStyle(): void;
static add(name: string, dialogDefinition: string | ((editor: editor) => dialog.IDialogDefinition)): void;
static addIframe(name: string, title: string, minWidth: number, minHeight: number, onContentLoad?: () => void, userDefinition?: { [key: string]: any }): void;
static addUIElement(typeName: string, builder: () => void): void;
static cancelButton(): void;
static exists(name: string | number): void; // NOTE: documentation says object, but it's an array accessor, so really a string or number will work
static getCurrent(): dialog;
static isTabEnabled(editor: editor, dialogName: string, tabName: string): boolean;
static okButton(): void;
}
namespace dialog {
namespace definition {
interface button extends uiElement {
disabled?: boolean;
}
interface checkbox extends uiElement {
default?: string;
validate?: () => boolean;
}
interface content {
accessKey?: string;
elements?: dialog.definition.uiElement[];
id?: string;
label?: string;
title?: string;
}
interface file extends labeledElement {
action?: string;
size?: string;
validate?: () => boolean;
}
interface fileButton extends uiElement {
filebrowser?: string;
for?: string;
validate?: () => boolean;
}
interface hbox extends uiElement {
children?: ui.dialog.uiElement[];
height?: number;
padding?: number;
validate?: () => boolean;
widths?: number[];
}
interface html extends uiElement {
html?: string;
}
interface labeledElement extends uiElement {
controlStyle?: string;
inputStyle?: string;
labelLayout?: string;
labelStyle?: string;
widths?: number[];
}
interface radio extends labeledElement {
default?: string;
items?: string[] | string[][];
validate?: () => boolean;
}
interface select extends labeledElement {
default?: string;
items?: string[] | string[][];
multiple?: boolean;
size?: number;
validate?: () => boolean;
}
interface textarea extends labeledElement {
bidi?: boolean;
cols?: number;
default?: string;
rows?: number;
validate?: () => boolean;
}
interface textInput extends labeledElement {
bidi?: boolean;
default?: string;
maxLength?: number;
size?: number;
validate?: () => boolean;
}
interface uiElement {
align?: string;
className?: string;
commit?: (widget: plugins.widget) => void;
id?: string;
label?: string;
onHide?: (elem: ui.dialog.uiElement) => void;
onLoad?: (elem: ui.dialog.uiElement) => void;
onShow?: (elem: ui.dialog.uiElement) => void;
requiredContent?: string | { [key: string]: any } | style;
setup?: (widget: plugins.widget) => void;
style?: string;
title?: string;
type?: string;
}
interface vbox extends uiElement {
children?: ui.dialog.uiElement[];
expand?: boolean;
heights?: number[];
padding?: number;
styles?: string;
width?: number[];
}
}
interface IDialogDefinition {
buttons?: dialog.definition.button[];
contents?: dialog.definition.content[];
height?: number;
minHeight?: number;
minWidth?: number;
onCancel?: () => void;
onLoad?: () => void;
onOk?: () => void;
onShow?: () => void;
onHide?: () => void;
resizable?: number;
title?: string;
width?: number;
}
}
class dialogCommand {
value: any;
constructor(dialogName: string, ext?: { tabId?: string });
}
interface dtdDefinition {
[outerTagName: string]: { [innerTagName: string]: 1 };
$block: { [tagName: string]: 1 };
$blockLimit: { [tagName: string]: 1 };
$cdata: { [tagName: string]: 1 };
$editable: { [tagName: string]: 1 };
$empty: { [tagName: string]: 1 };
$inline: { [tagName: string]: 1 };
$intermediate: { [tagName: string]: 1 };
$list: { [tagName: string]: 1 };
$listItem: { [tagName: string]: 1 };
$nonBodyContent: { [tagName: string]: 1 };
$nonEditable: { [tagName: string]: 1 };
$object: { [tagName: string]: 1 };
$removeEmpty: { [tagName: string]: 1 };
$tabIndex: { [tagName: string]: 1 };
$tableContent: { [tagName: string]: 1 };
$transparent: { [tagName: string]: 1 };
}
var dtd: dtdDefinition;
class editable extends dom.element {
hasFocus: boolean;
readonly status: string;
constructor(editor: editor, element: HTMLElement | dom.element);
attachClass(className: string): void;
attachListener(obj: event | editable, eventName: string, listenerFunction: (ei: eventInfo) => void, scopeobj?: {}, listenerData?: any, priority?: number): listenerRegistration;
changeAttr(attr: string, val: string): void;
detach(): void;
insertElement(element: dom.element, range?: dom.range): void;
insertHtml(data: string, mode?: string, range?: dom.range): void;
insertText(text: dom.text): void;
isInline(): boolean;
setReadOnly(isReadOnly: boolean): void;
}
class editor extends event {
readonly activeEnterMode: number;
readonly activeFilter: filter;
readonly activeShiftEnterMode: number;
readonly blockless: boolean;
readonly config: config;
readonly container: dom.element;
readonly contextMenu: plugins.contextMenu;
copyFormatting: plugins.copyformatting.state;
dataProcessor: dataProcessor;
readonly document: dom.document;
readonly element: dom.element;
readonly elementMode: number;
readonly enterMode: number;
readonly filter: filter;
readonly focusManager: focusManager;
readonly id: string;
readonly keystrokeHandler: keystrokeHandler;
readonly lang: any;
readonly langCode: string;
readonly mode: string;
readonly name: string;
readonly pasteFilter: filter;
readonly plugins: any;
readonly readOnly: boolean;
readonly shiftEnterMode: number;
readonly status: string;
readonly tabIndex: number;
readonly templates: any;
readonly title: any;
readonly toolbar: any;
readonly ui: ui;
readonly widgets: plugins.widget.repository;
readonly window: dom.window;
constructor(instanceConfig?: config, element?: dom.element, mode?: number);
addCommand(commandName: string, commandDefinition: commandDefinition): void;
addContentsCss(cssPath: string): void;
addFeature(feature: feature): boolean;
addMenuGroup(name: string, order?: number): void;
addMenuItem(name: string, definition?: IMenuItemDefinition): void;
addMenuItems(definitions: { [id: string]: IMenuItemDefinition }): void;
addMode(mode: string, exec: () => void): void;
addRemoveFormatFilter(func: (element: dom.element) => boolean): void;
applyStyle(style: style): void;
attachStyleStateChange(style: style, callback: (state: number) => void): void;
checkDirty(): boolean;
createFakeElement(realElement: dom.element, className: string, realElementType: string, isResizable: boolean): void;
createFakeParserElement(realElement: dom.element, className: string, realElementType: string, isResizable: boolean): void;
createRange(): dom.range;
destroy(noUpdate?: boolean): void;
editable(elementOrEditable?: dom.element | editable): editable;
elementPath(startNode?: dom.node): dom.elementPath;
execCommand(commandName: string, data?: any): boolean;
extractSelectedHtml(toString?: boolean, removeEmptyBlock?: boolean): dom.documentFragment | string | void;
focus(): void;
forceNextSelectionCheck(): void;
getClipboardData(callbackOrOptions: { title: string } | ((data: any) => void), callback: (data: any) => void): void;
getColorFromDialog(callback: (color: string) => void, scope?: { [key: string]: any }): void;
getCommand(commandName: string): command;
getCommandKeystroke(command: command | string): number | null;
getData(internal?: boolean): string;
getMenuItem(name: string): IMenuItemDefinition;
getResizable(forContents: boolean): dom.element;
getSelectedHtml(toString?: false): dom.documentFragment;
getSelectedHtml(toString: true): string;
getSelectedHtml(toString?: boolean): dom.documentFragment | string;
getSelection(forceRealSelection?: boolean): dom.selection;
getSnapshot(): string;
getStylesSet(callback: (stylesDefinitions: style.definition[]) => void): void;
getUiColor(): string;
insertElement(element: dom.element): void;
insertHtml(html: string, mode?: string, range?: dom.range): void;
insertText(text: string): void;
loadSnapshot(snapshot: any): void;
lockSelection(sel?: dom.selection): boolean;
openDialog(dialogName: string, callback: () => void): dialog;
popup(url: string, width?: number | string, height?: number | string, options?: string): void;
removeMenuItem(name: string): void;
removeStyle(style: style): void;
resetDirty(): void;
resetUndo(): void;
resize(width: number | string, height: number | string, isContentHeight?: boolean, resizeInner?: boolean): void;
restoreRealElement(fakeElement: dom.element): dom.element;
selectionChange(checkNow?: boolean): void;
setActiveEnterMode(enterMode: number, shiftEnterMode: number): void;
setActiveFilter(filter: filter): void;
setData(data: string, options?: { internal?: boolean; callback?: () => void; noSnapshot?: boolean; }): void;
setKeystroke(keystroke: number, behavior: string | boolean): void;
setKeystroke(keystroke: Array<[number, string | boolean]>): void;
setMode(newMode: string, callback: () => void): void;
setReadOnly(isReadOnly?: boolean): void;
setUiColor(color: string): void;
showNotification(message: string, type: plugins.notification.type, progressOrDuration: number): plugins.notification;
unlockSelection(restore?: boolean): void;
updateElement(): void;
}
namespace editor {
interface eventObject {
activeEnterModeChange?: (evt: eventInfo) => void;
activeFilterChange?: (evt: eventInfo) => void;
afterCommandExec?: (evt: eventInfo) => void;
afterInsertHtml?: (evt: eventInfo) => void;
afterPaste?: (evt: eventInfo) => void;
afterPasteFromWord?: (evt: eventInfo) => void;
afterSetData?: (evt: eventInfo) => void;
afterUndoImage?: (evt: eventInfo) => void;
ariaEditorHelpLabel?: (evt: eventInfo) => void;
ariaWidget?: (evt: eventInfo) => void;
autogrow?: (evt: eventInfo) => void;
beforeCommandExec?: (evt: eventInfo) => void;
beforeDestroy?: (evt: eventInfo) => void;
beforeGetData?: (evt: eventInfo) => void;
beforeModeUnload?: (evt: eventInfo) => void;
beforeSetMode?: (evt: eventInfo) => void;
beforeUndoImage?: (evt: eventInfo) => void;
blur?: (evt: eventInfo) => void;
change?: (evt: eventInfo) => void;
configLoaded?: (evt: eventInfo) => void;
contentDirChanged?: (evt: eventInfo) => void;
contentDom?: (evt: eventInfo) => void;
contentDomInvalidated?: (evt: eventInfo) => void;
contentDomUnload?: (evt: eventInfo) => void;
customConfigLoaded?: (evt: eventInfo) => void;
dataFiltered?: (evt: eventInfo) => void;
dataReady?: (evt: eventInfo) => void;
destroy?: (evt: eventInfo) => void;
dialogHide?: (evt: eventInfo) => void;
dialogShow?: (evt: eventInfo) => void;
dirChanged?: (evt: eventInfo) => void;
doubleclick?: (evt: eventInfo) => void;
dragend?: (evt: eventInfo) => void;
dragstart?: (evt: eventInfo) => void;
drop?: (evt: eventInfo) => void;
elementsPathUpdate?: (evt: eventInfo) => void;
fileUploadRequest?: (evt: eventInfo) => void;
fileUploadResponse?: (evt: eventInfo) => void;
floatingSpaceLayout?: (evt: eventInfo) => void;
f