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

   1 interface StringPathBookmark {
   2     start: string;
   3     end?: string;
   4 }
   5 interface RangeBookmark {
   6     rng: Range;
   7 }
   8 interface IdBookmark {
   9     id: string;
  10     keep?: boolean;
  11 }
  12 interface IndexBookmark {
  13     name: string;
  14     index: number;
  15 }
  16 interface PathBookmark {
  17     start: number[];
  18     end?: number[];
  19     isFakeCaret?: boolean;
  20 }
  21 declare type Bookmark = StringPathBookmark | RangeBookmark | IdBookmark | IndexBookmark | PathBookmark;
  22 declare type NormalizedEvent<E, T = any> = E & {
  23     readonly type: string;
  24     readonly target: T;
  25     readonly isDefaultPrevented: () => boolean;
  26     readonly preventDefault: () => void;
  27     readonly isPropagationStopped: () => boolean;
  28     readonly stopPropagation: () => void;
  29     readonly isImmediatePropagationStopped: () => boolean;
  30     readonly stopImmediatePropagation: () => void;
  31 };
  32 declare type MappedEvent<T, K extends string> = K extends keyof T ? T[K] : any;
  33 interface NativeEventMap {
  34     'beforepaste': Event;
  35     'blur': FocusEvent;
  36     'beforeinput': InputEvent;
  37     'click': MouseEvent;
  38     'compositionend': Event;
  39     'compositionstart': Event;
  40     'compositionupdate': Event;
  41     'contextmenu': PointerEvent;
  42     'copy': ClipboardEvent;
  43     'cut': ClipboardEvent;
  44     'dblclick': MouseEvent;
  45     'drag': DragEvent;
  46     'dragdrop': DragEvent;
  47     'dragend': DragEvent;
  48     'draggesture': DragEvent;
  49     'dragover': DragEvent;
  50     'dragstart': DragEvent;
  51     'drop': DragEvent;
  52     'focus': FocusEvent;
  53     'focusin': FocusEvent;
  54     'focusout': FocusEvent;
  55     'input': InputEvent;
  56     'keydown': KeyboardEvent;
  57     'keypress': KeyboardEvent;
  58     'keyup': KeyboardEvent;
  59     'mousedown': MouseEvent;
  60     'mouseenter': MouseEvent;
  61     'mouseleave': MouseEvent;
  62     'mousemove': MouseEvent;
  63     'mouseout': MouseEvent;
  64     'mouseover': MouseEvent;
  65     'mouseup': MouseEvent;
  66     'paste': ClipboardEvent;
  67     'selectionchange': Event;
  68     'submit': Event;
  69     'touchend': TouchEvent;
  70     'touchmove': TouchEvent;
  71     'touchstart': TouchEvent;
  72     'touchcancel': TouchEvent;
  73     'wheel': WheelEvent;
  74 }
  75 declare type EditorEvent<T> = NormalizedEvent<T>;
  76 interface EventDispatcherSettings {
  77     scope?: any;
  78     toggleEvent?: (name: string, state: boolean) => void | boolean;
  79     beforeFire?: <T>(args: EditorEvent<T>) => void;
  80 }
  81 interface EventDispatcherConstructor<T extends NativeEventMap> {
  82     readonly prototype: EventDispatcher<T>;
  83     new (settings?: EventDispatcherSettings): EventDispatcher<T>;
  84     isNative: (name: string) => boolean;
  85 }
  86 declare class EventDispatcher<T> {
  87     static isNative(name: string): boolean;
  88     private readonly settings;
  89     private readonly scope;
  90     private readonly toggleEvent;
  91     private bindings;
  92     constructor(settings?: Record<string, any>);
  93     fire<K extends string, U extends MappedEvent<T, K>>(name: K, args?: U): EditorEvent<U>;
  94     on<K extends string>(name: K, callback: false | ((event: EditorEvent<MappedEvent<T, K>>) => void), prepend?: boolean, extra?: {}): this;
  95     off<K extends string>(name?: K, callback?: (event: EditorEvent<MappedEvent<T, K>>) => void): this;
  96     once<K extends string>(name: K, callback: (event: EditorEvent<MappedEvent<T, K>>) => void, prepend?: boolean): this;
  97     has(name: string): boolean;
  98 }
  99 declare const enum UndoLevelType {
 100     Fragmented = "fragmented",
 101     Complete = "complete"
 102 }
 103 interface UndoLevel {
 104     type: UndoLevelType;
 105     fragments: string[];
 106     content: string;
 107     bookmark: Bookmark;
 108     beforeBookmark: Bookmark;
 109 }
 110 interface UndoManager {
 111     data: UndoLevel[];
 112     typing: boolean;
 113     add: (level?: UndoLevel, event?: EditorEvent<any>) => UndoLevel;
 114     beforeChange: () => void;
 115     undo: () => UndoLevel;
 116     redo: () => UndoLevel;
 117     clear: () => void;
 118     reset: () => void;
 119     hasUndo: () => boolean;
 120     hasRedo: () => boolean;
 121     transact: (callback: () => void) => UndoLevel;
 122     ignore: (callback: () => void) => void;
 123     extra: (callback1: () => void, callback2: () => void) => void;
 124 }
 125 declare type ArrayCallback$1<T, R> = (x: T, i: number, xs: ReadonlyArray<T>) => R;
 126 declare type ObjCallback$1<T, R> = (value: T, key: string, obj: Record<string, T>) => R;
 127 declare type ArrayCallback<T, R> = ArrayCallback$1<T, R>;
 128 declare type ObjCallback<T, R> = ObjCallback$1<T, R>;
 129 interface Tools {
 130     is: (obj: any, type: string) => boolean;
 131     isArray: <T>(arr: any) => arr is Array<T>;
 132     inArray: <T>(arr: ArrayLike<T>, value: T) => number;
 133     grep: {
 134         <T>(arr: ArrayLike<T> | null | undefined, pred?: ArrayCallback<T, boolean>): T[];
 135         <T>(arr: Record<string, T> | null | undefined, pred?: ObjCallback<T, boolean>): T[];
 136     };
 137     trim: (str: string) => string;
 138     toArray: <T>(obj: ArrayLike<T>) => T[];
 139     hasOwn: (obj: any, name: string) => boolean;
 140     makeMap: <T>(items: ArrayLike<T> | string, delim?: string | RegExp, map?: Record<string, T | string>) => Record<string, T | string>;
 141     each: {
 142         <T>(arr: ArrayLike<T> | null | undefined, cb: ArrayCallback<T, void | boolean>, scope?: any): boolean;
 143         <T>(obj: Record<string, T> | null | undefined, cb: ObjCallback<T, void | boolean>, scope?: any): boolean;
 144     };
 145     map: {
 146         <T, R>(arr: ArrayLike<T> | null | undefined, cb: ArrayCallback<T, R>): R[];
 147         <T, R>(obj: Record<string, T> | null | undefined, cb: ObjCallback<T, R>): R[];
 148     };
 149     extend: (obj: Object, ext: Object, ...objs: Object[]) => any;
 150     create: (name: string, p: Object, root?: Object) => void;
 151     walk: <T = any>(obj: T, f: Function, n?: keyof T, scope?: any) => void;
 152     createNS: (name: string, o?: Object) => any;
 153     resolve: (path: string, o?: Object) => any;
 154     explode: (s: string, d?: string | RegExp) => string[];
 155     _addCacheSuffix: (url: string) => string;
 156 }
 157 declare type EventUtilsCallback<T> = (event: EventUtilsEvent<T>) => void;
 158 declare type EventUtilsEvent<T> = NormalizedEvent<T> & {
 159     metaKey: boolean;
 160 };
 161 interface EventUtilsConstructor {
 162     readonly prototype: EventUtils;
 163     new (): EventUtils;
 164     Event: EventUtils;
 165 }
 166 declare class EventUtils {
 167     static Event: EventUtils;
 168     domLoaded: boolean;
 169     events: Record<string, any>;
 170     private readonly expando;
 171     private hasFocusIn;
 172     private hasMouseEnterLeave;
 173     private mouseEnterLeave;
 174     private count;
 175     constructor();
 176     bind<K extends keyof HTMLElementEventMap>(target: any, name: K, callback: EventUtilsCallback<HTMLElementEventMap[K]>, scope?: any): EventUtilsCallback<HTMLElementEventMap[K]>;
 177     bind<T = any>(target: any, names: string, callback: EventUtilsCallback<T>, scope?: any): EventUtilsCallback<T>;
 178     unbind<K extends keyof HTMLElementEventMap>(target: any, name: K, callback?: EventUtilsCallback<HTMLElementEventMap[K]>): this;
 179     unbind<T = any>(target: any, names: string, callback?: EventUtilsCallback<T>): this;
 180     unbind(target: any): this;
 181     fire(target: any, name: string, args?: {}): this;
 182     clean(target: any): this;
 183     destroy(): void;
 184     cancel<T = any>(e: EventUtilsEvent<T>): boolean;
 185     private executeHandlers;
 186 }
 187 declare type DomQuerySelector<T extends Node> = string | T | T[] | DomQuery<T>;
 188 declare type DomQueryInitSelector<T extends Node> = DomQuerySelector<T> | Window;
 189 interface Hook {
 190     get: <T extends Node>(elm: T) => string;
 191     set: <T extends Node>($elm: DomQuery<T>, value: string | null) => void;
 192 }
 193 interface DomQueryConstructor {
 194     readonly prototype: DomQuery;
 195     attrHooks: Record<string, Hook>;
 196     cssHooks: Record<string, Hook>;
 197     fn: DomQuery;
 198     find: any;
 199     expr: {
 200         cacheLength: number;
 201         createPseudo: Function;
 202         match: Record<string, RegExp>;
 203         attrHandle: {};
 204         find: Record<string, Function>;
 205         relative: Record<string, {
 206             dir: string;
 207             first?: boolean;
 208         }>;
 209         preFilter: Record<string, Function>;
 210         filter: Record<string, Function>;
 211         pseudos: Record<string, Function>;
 212     };
 213     extend: Tools['extend'];
 214     isArray: Tools['isArray'];
 215     new <T extends Node = Node>(selector?: DomQueryInitSelector<T>, context?: Node): DomQuery<T>;
 216     <T extends Node = Node>(selector?: DomQueryInitSelector<T>, context?: Node): DomQuery<T>;
 217     overrideDefaults(callback: () => {
 218         context: Node;
 219         element: Element;
 220     }): DomQueryConstructor;
 221     makeArray<T>(object: T): T[];
 222     inArray<T>(item: {}, array: T[]): number;
 223     each<T>(obj: T[], callback: (i: number, value: T) => void): void;
 224     each<T>(obj: T, callback: (key: string, obj: T[keyof T]) => void): void;
 225     trim(str: string): string;
 226     grep<T>(array: T[], callback: (item: any, i: number) => boolean): T[];
 227     unique<T>(results: T[]): T[];
 228     text(elem: Node): string;
 229     contains(context: any, elem: Node): boolean;
 230     filter(expr: string, elems: Node[], not?: boolean): any;
 231 }
 232 interface DomQuery<T extends Node = Node> extends ArrayLike<T> {
 233     init: (selector?: DomQueryInitSelector<T>, context?: Node) => void;
 234     context: T;
 235     length: number;
 236     selector: string;
 237     add(items: Array<string | T> | DomQuery<T>, sort?: boolean): this;
 238     addClass(className: string): this;
 239     after(content: DomQuerySelector<T>): this;
 240     append(content: DomQuerySelector<T>): this;
 241     appendTo(val: DomQuerySelector<T>): this;
 242     attr(name: string, value: string | boolean | number | null): this;
 243     attr(attrs: Record<string, string | boolean | number | null>): this;
 244     attr(name: string): string;
 245     before(content: DomQuerySelector<T>): this;
 246     children(selector?: string): DomQuery<Node & ChildNode>;
 247     clone(): this;
 248     closest(selector: DomQuerySelector<T>): this;
 249     contents(selector?: string): DomQuery<Node & ChildNode>;
 250     css(name: string, value: string | number | null): this;
 251     css(styles: Record<string, string | number | null>): this;
 252     css(name: string): string;
 253     each(callback: (i: number, value: T) => void): this;
 254     empty(): this;
 255     eq(index: number): this;
 256     filter(selector: string | ((i: number, item: any) => boolean)): this;
 257     find<K extends keyof HTMLElementTagNameMap>(selector: K): DomQuery<HTMLElementTagNameMap[K]>;
 258     find<T extends Node>(selector: string): DomQuery<T>;
 259     first(): this;
 260     hasClass(className: string): boolean;
 261     hide(): this;
 262     html(value: string): this;
 263     html(): string;
 264     is(selector: string | ((i: number, item: any) => boolean)): boolean;
 265     last(): this;
 266     next(selector?: string): DomQuery<Node & ChildNode>;
 267     nextUntil(selector: DomQuerySelector<T>, until?: string): DomQuery<Node & ChildNode>;
 268     off<K extends keyof HTMLElementEventMap>(name: K, callback?: EventUtilsCallback<HTMLElementEventMap[K]>): this;
 269     off<U>(name?: string, callback?: EventUtilsCallback<U>): this;
 270     offset(offset?: {}): {} | this;
 271     on<K extends keyof HTMLElementEventMap>(name: K, callback: EventUtilsCallback<HTMLElementEventMap[K]>): this;
 272     on<U>(name: string, callback: EventUtilsCallback<U>): this;
 273     parent(selector?: string): DomQuery<Node>;
 274     parents(selector?: string): DomQuery<Node>;
 275     parentsUntil(selector: DomQuerySelector<T>, filter?: string): DomQuery<Node>;
 276     prepend(content: DomQuerySelector<T>): this;
 277     prependTo(val: DomQuerySelector<T>): this;
 278     prev(selector?: string): DomQuery<Node & ChildNode>;
 279     prevUntil(selector: DomQuerySelector<T>, filter?: string): DomQuery<Node & ChildNode>;
 280     prop(name: string, value: string): this;
 281     prop(props: Record<string, string | number>): this;
 282     prop(name: string): string;
 283     push(...items: T[]): number;
 284     remove(): this;
 285     removeAttr(name: string): this;
 286     removeClass(className: string): this;
 287     replaceWith(content: DomQuerySelector<T>): this;
 288     show(): this;
 289     slice(start: number, end?: number): this;
 290     splice(start: number, deleteCount?: number): T[];
 291     sort(compareFn?: (a: T, b: T) => number): T[];
 292     text(value: string): DomQuery;
 293     text(): string;
 294     toArray(): T[];
 295     toggleClass(className: string, state?: boolean): this;
 296     trigger(name: string | {
 297         type: string;
 298     }): this;
 299     unwrap(): this;
 300     wrap(content: DomQuerySelector<T>): this;
 301     wrapAll(content: DomQuerySelector<T>): this;
 302     wrapInner(content: string): this;
 303 }
 304 declare type SchemaType = 'html4' | 'html5' | 'html5-strict';
 305 interface SchemaSettings {
 306     block_elements?: string;
 307     boolean_attributes?: string;
 308     custom_elements?: string;
 309     extended_valid_elements?: string;
 310     invalid_elements?: string;
 311     invalid_styles?: string | Record<string, string>;
 312     move_caret_before_on_enter_elements?: string;
 313     non_empty_elements?: string;
 314     schema?: SchemaType;
 315     self_closing_elements?: string;
 316     short_ended_elements?: string;
 317     special?: string;
 318     text_block_elements?: string;
 319     text_inline_elements?: string;
 320     valid_children?: string;
 321     valid_classes?: string | Record<string, string>;
 322     valid_elements?: string;
 323     valid_styles?: string | Record<string, string>;
 324     verify_html?: boolean;
 325     whitespace_elements?: string;
 326 }
 327 interface Attribute {
 328     required?: boolean;
 329     defaultValue?: string;
 330     forcedValue?: string;
 331     validValues?: any;
 332 }
 333 interface DefaultAttribute {
 334     name: string;
 335     value: string;
 336 }
 337 interface AttributePattern {
 338     defaultValue?: string;
 339     forcedValue?: string;
 340     pattern: RegExp;
 341     required?: boolean;
 342     validValues?: Record<string, string>;
 343 }
 344 interface ElementRule {
 345     attributes: Record<string, Attribute>;
 346     attributesDefault?: DefaultAttribute[];
 347     attributesForced?: DefaultAttribute[];
 348     attributesOrder: string[];
 349     attributePatterns?: AttributePattern[];
 350     attributesRequired?: string[];
 351     paddEmpty?: boolean;
 352     removeEmpty?: boolean;
 353     removeEmptyAttrs?: boolean;
 354 }
 355 interface SchemaElement extends ElementRule {
 356     outputName?: string;
 357     parentsRequired?: string[];
 358     pattern?: RegExp;
 359 }
 360 interface SchemaMap {
 361     [name: string]: {};
 362 }
 363 interface SchemaRegExpMap {
 364     [name: string]: RegExp;
 365 }
 366 interface Schema {
 367     children: Record<string, SchemaMap>;
 368     elements: Record<string, SchemaElement>;
 369     getValidStyles: () => Record<string, string[]> | undefined;
 370     getValidClasses: () => Record<string, SchemaMap> | undefined;
 371     getBlockElements: () => SchemaMap;
 372     getInvalidStyles: () => Record<string, SchemaMap> | undefined;
 373     getShortEndedElements: () => SchemaMap;
 374     getTextBlockElements: () => SchemaMap;
 375     getTextInlineElements: () => SchemaMap;
 376     getBoolAttrs: () => SchemaMap;
 377     getElementRule: (name: string) => SchemaElement | undefined;
 378     getSelfClosingElements: () => SchemaMap;
 379     getNonEmptyElements: () => SchemaMap;
 380     getMoveCaretBeforeOnEnterElements: () => SchemaMap;
 381     getWhiteSpaceElements: () => SchemaMap;
 382     getSpecialElements: () => SchemaRegExpMap;
 383     isValidChild: (name: string, child: string) => boolean;
 384     isValid: (name: string, attr?: string) => boolean;
 385     getCustomElements: () => SchemaMap;
 386     addValidElements: (validElements: string) => void;
 387     setValidElements: (validElements: string) => void;
 388     addCustomElements: (customElements: string) => void;
 389     addValidChildren: (validChildren: any) => void;
 390 }
 391 declare type Attributes$1 = Array<{
 392     name: string;
 393     value: string;
 394 }> & {
 395     map: Record<string, string>;
 396 };
 397 interface AstNodeConstructor {
 398     readonly prototype: AstNode;
 399     new (name: string, type: number): AstNode;
 400     create(name: string, attrs?: Record<string, string>): AstNode;
 401 }
 402 declare class AstNode {
 403     static create(name: string, attrs?: Record<string, string>): AstNode;
 404     name: string;
 405     type: number;
 406     attributes?: Attributes$1;
 407     value?: string;
 408     shortEnded?: boolean;
 409     parent?: AstNode;
 410     firstChild?: AstNode;
 411     lastChild?: AstNode;
 412     next?: AstNode;
 413     prev?: AstNode;
 414     raw?: boolean;
 415     fixed?: boolean;
 416     constructor(name: string, type: number);
 417     replace(node: AstNode): AstNode;
 418     attr(name: string, value: string | null): AstNode | undefined;
 419     attr(name: Record<string, string | null>): AstNode | undefined;
 420     attr(name: string): string | undefined;
 421     clone(): AstNode;
 422     wrap(wrapper: AstNode): AstNode;
 423     unwrap(): void;
 424     remove(): AstNode;
 425     append(node: AstNode): AstNode;
 426     insert(node: AstNode, refNode: AstNode, before?: boolean): AstNode;
 427     getAll(name: string): AstNode[];
 428     children(): AstNode[];
 429     empty(): AstNode;
 430     isEmpty(elements: SchemaMap, whitespace?: SchemaMap, predicate?: (node: AstNode) => boolean): boolean;
 431     walk(prev?: boolean): AstNode;
 432 }
 433 declare type Content = string | AstNode;
 434 declare type ContentFormat = 'raw' | 'text' | 'html' | 'tree';
 435 interface GetContentArgs {
 436     format?: ContentFormat;
 437     get?: boolean;
 438     content?: string;
 439     getInner?: boolean;
 440     no_events?: boolean;
 441     [key: string]: any;
 442 }
 443 interface SetContentArgs {
 444     format?: string;
 445     set?: boolean;
 446     content?: string;
 447     no_events?: boolean;
 448     no_selection?: boolean;
 449 }
 450 interface BlobInfoData {
 451     id?: string;
 452     name?: string;
 453     filename?: string;
 454     blob: Blob;
 455     base64: string;
 456     blobUri?: string;
 457     uri?: string;
 458 }
 459 interface BlobInfo {
 460     id: () => string;
 461     name: () => string;
 462     filename: () => string;
 463     blob: () => Blob;
 464     base64: () => string;
 465     blobUri: () => string;
 466     uri: () => string | undefined;
 467 }
 468 interface BlobCache {
 469     create: (o: string | BlobInfoData, blob?: Blob, base64?: string, name?: string, filename?: string) => BlobInfo;
 470     add: (blobInfo: BlobInfo) => void;
 471     get: (id: string) => BlobInfo | undefined;
 472     getByUri: (blobUri: string) => BlobInfo | undefined;
 473     getByData: (base64: string, type: string) => BlobInfo | undefined;
 474     findFirst: (predicate: (blobInfo: BlobInfo) => boolean) => BlobInfo | undefined;
 475     removeByUri: (blobUri: string) => void;
 476     destroy: () => void;
 477 }
 478 interface NotificationManagerImpl {
 479     open: (spec: NotificationSpec, closeCallback?: () => void) => NotificationApi;
 480     close: <T extends NotificationApi>(notification: T) => void;
 481     reposition: <T extends NotificationApi>(notifications: T[]) => void;
 482     getArgs: <T extends NotificationApi>(notification: T) => NotificationSpec;
 483 }
 484 interface NotificationSpec {
 485     type?: 'info' | 'warning' | 'error' | 'success';
 486     text: string;
 487     icon?: string;
 488     progressBar?: boolean;
 489     timeout?: number;
 490     closeButton?: boolean;
 491 }
 492 interface NotificationApi {
 493     close: () => void;
 494     progressBar: {
 495         value: (percent: number) => void;
 496     };
 497     text: (text: string) => void;
 498     moveTo: (x: number, y: number) => void;
 499     moveRel: (element: Element, rel: 'tc-tc' | 'bc-bc' | 'bc-tc' | 'tc-bc' | 'banner') => void;
 500     getEl: () => HTMLElement;
 501     settings: NotificationSpec;
 502 }
 503 interface NotificationManager {
 504     open: (spec: NotificationSpec) => NotificationApi;
 505     close: () => void;
 506     getNotifications: () => NotificationApi[];
 507 }
 508 interface UploadFailureOptions {
 509     remove?: boolean;
 510 }
 511 declare type UploadHandler = (blobInfo: BlobInfo, success: (url: string) => void, failure: (err: string, options?: UploadFailureOptions) => void, progress?: (percent: number) => void) => void;
 512 interface UploadResult$2 {
 513     url: string;
 514     blobInfo: BlobInfo;
 515     status: boolean;
 516     error?: {
 517         options: UploadFailureOptions;
 518         message: string;
 519     };
 520 }
 521 interface RangeLikeObject {
 522     startContainer: Node;
 523     startOffset: number;
 524     endContainer: Node;
 525     endOffset: number;
 526 }
 527 declare type ApplyFormat = BlockFormat | InlineFormat | SelectorFormat;
 528 declare type RemoveFormat = RemoveBlockFormat | RemoveInlineFormat | RemoveSelectorFormat;
 529 declare type Format = ApplyFormat | RemoveFormat;
 530 declare type Formats = Record<string, Format | Format[]>;
 531 declare type FormatAttrOrStyleValue = string | ((vars?: FormatVars) => string);
 532 declare type FormatVars = Record<string, string | null>;
 533 interface BaseFormat<T> {
 534     ceFalseOverride?: boolean;
 535     classes?: string | string[];
 536     collapsed?: boolean;
 537     exact?: boolean;
 538     expand?: boolean;
 539     links?: boolean;
 540     mixed?: boolean;
 541     block_expand?: boolean;
 542     onmatch?: (node: Node, fmt: T, itemName: string) => boolean;
 543     remove?: 'none' | 'empty' | 'all';
 544     remove_similar?: boolean;
 545     split?: boolean;
 546     deep?: boolean;
 547     preserve_attributes?: string[];
 548 }
 549 interface Block {
 550     block: string;
 551     list_block?: string;
 552     wrapper?: boolean;
 553 }
 554 interface Inline {
 555     inline: string;
 556 }
 557 interface Selector {
 558     selector: string;
 559     inherit?: boolean;
 560 }
 561 interface CommonFormat<T> extends BaseFormat<T> {
 562     attributes?: Record<string, FormatAttrOrStyleValue>;
 563     styles?: Record<string, FormatAttrOrStyleValue>;
 564     toggle?: boolean;
 565     preview?: string | false;
 566     onformat?: (elm: Node, fmt: T, vars?: FormatVars, node?: Node | RangeLikeObject) => void;
 567     clear_child_styles?: boolean;
 568     merge_siblings?: boolean;
 569     merge_with_parents?: boolean;
 570     defaultBlock?: string;
 571 }
 572 interface BlockFormat extends Block, CommonFormat<BlockFormat> {
 573 }
 574 interface InlineFormat extends Inline, CommonFormat<InlineFormat> {
 575 }
 576 interface SelectorFormat extends Selector, CommonFormat<SelectorFormat> {
 577 }
 578 interface CommonRemoveFormat<T> extends BaseFormat<T> {
 579     attributes?: string[] | Record<string, FormatAttrOrStyleValue>;
 580     styles?: string[] | Record<string, FormatAttrOrStyleValue>;
 581 }
 582 interface RemoveBlockFormat extends Block, CommonRemoveFormat<RemoveBlockFormat> {
 583 }
 584 interface RemoveInlineFormat extends Inline, CommonRemoveFormat<RemoveInlineFormat> {
 585 }
 586 interface RemoveSelectorFormat extends Selector, CommonRemoveFormat<RemoveSelectorFormat> {
 587 }
 588 type Format_d_Formats = Formats;
 589 type Format_d_Format = Format;
 590 type Format_d_ApplyFormat = ApplyFormat;
 591 type Format_d_BlockFormat = BlockFormat;
 592 type Format_d_InlineFormat = InlineFormat;
 593 type Format_d_SelectorFormat = SelectorFormat;
 594 type Format_d_RemoveFormat = RemoveFormat;
 595 type Format_d_RemoveBlockFormat = RemoveBlockFormat;
 596 type Format_d_RemoveInlineFormat = RemoveInlineFormat;
 597 type Format_d_RemoveSelectorFormat = RemoveSelectorFormat;
 598 declare namespace Format_d {
 599     export { Format_d_Formats as Formats, Format_d_Format as Format, Format_d_ApplyFormat as ApplyFormat, Format_d_BlockFormat as BlockFormat, Format_d_InlineFormat as InlineFormat, Format_d_SelectorFormat as SelectorFormat, Format_d_RemoveFormat as RemoveFormat, Format_d_RemoveBlockFormat as RemoveBlockFormat, Format_d_RemoveInlineFormat as RemoveInlineFormat, Format_d_RemoveSelectorFormat as RemoveSelectorFormat, };
 600 }
 601 declare type StyleFormat = BlockStyleFormat | InlineStyleFormat | SelectorStyleFormat;
 602 declare type AllowedFormat = Separator | FormatReference | StyleFormat | NestedFormatting;
 603 interface Separator {
 604     title: string;
 605 }
 606 interface FormatReference {
 607     title: string;
 608     format: string;
 609     icon?: string;
 610 }
 611 interface NestedFormatting {
 612     title: string;
 613     items: Array<FormatReference | StyleFormat>;
 614 }
 615 interface CommonStyleFormat {
 616     name?: string;
 617     title: string;
 618     icon?: string;
 619 }
 620 interface BlockStyleFormat extends BlockFormat, CommonStyleFormat {
 621 }
 622 interface InlineStyleFormat extends InlineFormat, CommonStyleFormat {
 623 }
 624 interface SelectorStyleFormat extends SelectorFormat, CommonStyleFormat {
 625 }
 626 interface AlertBannerSpec {
 627     type: 'alertbanner';
 628     level: 'info' | 'warn' | 'error' | 'success';
 629     text: string;
 630     icon: string;
 631     url?: string;
 632 }
 633 interface ButtonSpec {
 634     type: 'button';
 635     text: string;
 636     disabled?: boolean;
 637     primary?: boolean;
 638     name?: string;
 639     icon?: string;
 640     borderless?: boolean;
 641 }
 642 interface CheckboxSpec {
 643     name: string;
 644     type: 'checkbox';
 645     label: string;
 646     disabled?: boolean;
 647 }
 648 interface FormComponentSpec {
 649     type: string;
 650     name: string;
 651 }
 652 interface FormComponentWithLabelSpec extends FormComponentSpec {
 653     label?: string;
 654 }
 655 interface CollectionSpec extends FormComponentWithLabelSpec {
 656     type: 'collection';
 657 }
 658 interface ColorInputSpec extends FormComponentWithLabelSpec {
 659     type: 'colorinput';
 660 }
 661 interface ColorPickerSpec extends FormComponentWithLabelSpec {
 662     type: 'colorpicker';
 663 }
 664 interface CustomEditorInit {
 665     setValue: (value: string) => void;
 666     getValue: () => string;
 667     destroy: () => void;
 668 }
 669 declare type CustomEditorInitFn = (elm: HTMLElement, settings: any) => Promise<CustomEditorInit>;
 670 interface CustomEditorOldSpec extends FormComponentSpec {
 671     type: 'customeditor';
 672     tag?: string;
 673     init: (e: HTMLElement) => Promise<CustomEditorInit>;
 674 }
 675 interface CustomEditorNewSpec extends FormComponentSpec {
 676     type: 'customeditor';
 677     tag?: string;
 678     scriptId: string;
 679     scriptUrl: string;
 680     settings?: any;
 681 }
 682 declare type CustomEditorSpec = CustomEditorOldSpec | CustomEditorNewSpec;
 683 interface DropZoneSpec extends FormComponentWithLabelSpec {
 684     type: 'dropzone';
 685 }
 686 interface GridSpec {
 687     type: 'grid';
 688     columns: number;
 689     items: BodyComponentSpec[];
 690 }
 691 interface HtmlPanelSpec {
 692     type: 'htmlpanel';
 693     html: string;
 694     presets?: 'presentation' | 'document';
 695 }
 696 interface IframeSpec extends FormComponentWithLabelSpec {
 697     type: 'iframe';
 698     sandboxed?: boolean;
 699 }
 700 interface ImageToolsState {
 701     blob: Blob;
 702     url: string;
 703 }
 704 interface ImageToolsSpec extends FormComponentWithLabelSpec {
 705     type: 'imagetools';
 706     currentState: ImageToolsState;
 707 }
 708 interface InputSpec extends FormComponentWithLabelSpec {
 709     type: 'input';
 710     inputMode?: string;
 711     placeholder?: string;
 712     maximized?: boolean;
 713     disabled?: boolean;
 714 }
 715 interface LabelSpec {
 716     type: 'label';
 717     label: string;
 718     items: BodyComponentSpec[];
 719 }
 720 interface ListBoxSingleItemSpec {
 721     text: string;
 722     value: string;
 723 }
 724 interface ListBoxNestedItemSpec {
 725     text: string;
 726     items: ListBoxItemSpec[];
 727 }
 728 declare type ListBoxItemSpec = ListBoxNestedItemSpec | ListBoxSingleItemSpec;
 729 interface ListBoxSpec extends FormComponentWithLabelSpec {
 730     type: 'listbox';
 731     items: ListBoxItemSpec[];
 732     disabled?: boolean;
 733 }
 734 interface PanelSpec {
 735     type: 'panel';
 736     classes?: string[];
 737     items: BodyComponentSpec[];
 738 }
 739 interface SelectBoxItemSpec {
 740     text: string;
 741     value: string;
 742 }
 743 interface SelectBoxSpec extends FormComponentWithLabelSpec {
 744     type: 'selectbox';
 745     items: SelectBoxItemSpec[];
 746     size?: number;
 747     disabled?: boolean;
 748 }
 749 interface SizeInputSpec extends FormComponentWithLabelSpec {
 750     type: 'sizeinput';
 751     constrain?: boolean;
 752     disabled?: boolean;
 753 }
 754 interface TableSpec {
 755     type: 'table';
 756     header: string[];
 757     cells: string[][];
 758 }
 759 interface TextAreaSpec extends FormComponentWithLabelSpec {
 760     type: 'textarea';
 761     placeholder?: string;
 762     maximized?: boolean;
 763     disabled?: boolean;
 764 }
 765 interface UrlInputSpec extends FormComponentWithLabelSpec {
 766     type: 'urlinput';
 767     filetype?: 'image' | 'media' | 'file';
 768     disabled?: boolean;
 769 }
 770 declare type BodyComponentSpec = BarSpec | ButtonSpec | CheckboxSpec | TextAreaSpec | InputSpec | ListBoxSpec | SelectBoxSpec | SizeInputSpec | IframeSpec | HtmlPanelSpec | UrlInputSpec | DropZoneSpec | ColorInputSpec | GridSpec | ColorPickerSpec | ImageToolsSpec | AlertBannerSpec | CollectionSpec | LabelSpec | TableSpec | PanelSpec | CustomEditorSpec;
 771 interface BarSpec {
 772     type: 'bar';
 773     items: BodyComponentSpec[];
 774 }
 775 interface CommonMenuItemSpec {
 776     disabled?: boolean;
 777     text?: string;
 778     value?: string;
 779     meta?: Record<string, any>;
 780     shortcut?: string;
 781 }
 782 interface CommonMenuItemInstanceApi {
 783     isDisabled: () => boolean;
 784     setDisabled: (state: boolean) => void;
 785 }
 786 interface DialogToggleMenuItemSpec extends CommonMenuItemSpec {
 787     type?: 'togglemenuitem';
 788     name: string;
 789 }
 790 declare type DialogFooterMenuButtonItemSpec = DialogToggleMenuItemSpec;
 791 interface BaseDialogFooterButtonSpec {
 792     name?: string;
 793     align?: 'start' | 'end';
 794     primary?: boolean;
 795     disabled?: boolean;
 796     icon?: string;
 797 }
 798 interface DialogFooterNormalButtonSpec extends BaseDialogFooterButtonSpec {
 799     type: 'submit' | 'cancel' | 'custom';
 800     text: string;
 801 }
 802 interface DialogFooterMenuButtonSpec extends BaseDialogFooterButtonSpec {
 803     type: 'menu';
 804     text?: string;
 805     tooltip?: string;
 806     icon?: string;
 807     items: DialogFooterMenuButtonItemSpec[];
 808 }
 809 declare type DialogFooterButtonSpec = DialogFooterNormalButtonSpec | DialogFooterMenuButtonSpec;
 810 interface TabSpec {
 811     name?: string;
 812     title: string;
 813     items: BodyComponentSpec[];
 814 }
 815 interface TabPanelSpec {
 816     type: 'tabpanel';
 817     tabs: TabSpec[];
 818 }
 819 declare type DialogDataItem = any;
 820 declare type DialogData = Record<string, DialogDataItem>;
 821 interface DialogInstanceApi<T extends DialogData> {
 822     getData: () => T;
 823     setData: (data: Partial<T>) => void;
 824     disable: (name: string) => void;
 825     focus: (name: string) => void;
 826     showTab: (name: string) => void;
 827     redial: (nu: DialogSpec<T>) => void;
 828     enable: (name: string) => void;
 829     block: (msg: string) => void;
 830     unblock: () => void;
 831     close: () => void;
 832 }
 833 interface DialogActionDetails {
 834     name: string;
 835     value?: any;
 836 }
 837 interface DialogChangeDetails<T> {
 838     name: keyof T;
 839 }
 840 interface DialogTabChangeDetails {
 841     newTabName: string;
 842     oldTabName: string;
 843 }
 844 declare type DialogActionHandler<T> = (api: DialogInstanceApi<T>, details: DialogActionDetails) => void;
 845 declare type DialogChangeHandler<T> = (api: DialogInstanceApi<T>, details: DialogChangeDetails<T>) => void;
 846 declare type DialogSubmitHandler<T> = (api: DialogInstanceApi<T>) => void;
 847 declare type DialogCloseHandler = () => void;
 848 declare type DialogCancelHandler<T> = (api: DialogInstanceApi<T>) => void;
 849 declare type DialogTabChangeHandler<T> = (api: DialogInstanceApi<T>, details: DialogTabChangeDetails) => void;
 850 declare type DialogSize = 'normal' | 'medium' | 'large';
 851 interface DialogSpec<T extends DialogData> {
 852     title: string;
 853     size?: DialogSize;
 854     body: TabPanelSpec | PanelSpec;
 855     buttons: DialogFooterButtonSpec[];
 856     initialData?: T;
 857     onAction?: DialogActionHandler<T>;
 858     onChange?: DialogChangeHandler<T>;
 859     onSubmit?: DialogSubmitHandler<T>;
 860     onClose?: DialogCloseHandler;
 861     onCancel?: DialogCancelHandler<T>;
 862     onTabChange?: DialogTabChangeHandler<T>;
 863 }
 864 interface UrlDialogInstanceApi {
 865     block: (msg: string) => void;
 866     unblock: () => void;
 867     close: () => void;
 868     sendMessage: (msg: any) => void;
 869 }
 870 interface UrlDialogActionDetails {
 871     name: string;
 872     value?: any;
 873 }
 874 interface UrlDialogMessage {
 875     mceAction: string;
 876     [key: string]: any;
 877 }
 878 declare type UrlDialogActionHandler = (api: UrlDialogInstanceApi, actions: UrlDialogActionDetails) => void;
 879 declare type UrlDialogCloseHandler = () => void;
 880 declare type UrlDialogCancelHandler = (api: UrlDialogInstanceApi) => void;
 881 declare type UrlDialogMessageHandler = (api: UrlDialogInstanceApi, message: UrlDialogMessage) => void;
 882 interface UrlDialogFooterButtonSpec extends DialogFooterNormalButtonSpec {
 883     type: 'cancel' | 'custom';
 884 }
 885 interface UrlDialogSpec {
 886     title: string;
 887     url: string;
 888     height?: number;
 889     width?: number;
 890     buttons?: UrlDialogFooterButtonSpec[];
 891     onAction?: UrlDialogActionHandler;
 892     onClose?: UrlDialogCloseHandler;
 893     onCancel?: UrlDialogCancelHandler;
 894     onMessage?: UrlDialogMessageHandler;
 895 }
 896 declare type CardContainerDirection = 'vertical' | 'horizontal';
 897 declare type CardContainerAlign = 'left' | 'right';
 898 declare type CardContainerValign = 'top' | 'middle' | 'bottom';
 899 interface CardContainerSpec {
 900     type: 'cardcontainer';
 901     items: CardItemSpec[];
 902     direction?: CardContainerDirection;
 903     align?: CardContainerAlign;
 904     valign?: CardContainerValign;
 905 }
 906 interface CardImageSpec {
 907     type: 'cardimage';
 908     src: string;
 909     alt?: string;
 910     classes?: string[];
 911 }
 912 interface CardTextSpec {
 913     type: 'cardtext';
 914     text: string;
 915     name?: string;
 916     classes?: string[];
 917 }
 918 declare type CardItemSpec = CardContainerSpec | CardImageSpec | CardTextSpec;
 919 interface CardMenuItemInstanceApi extends CommonMenuItemInstanceApi {
 920 }
 921 interface CardMenuItemSpec extends Omit<CommonMenuItemSpec, 'text' | 'shortcut'> {
 922     type: 'cardmenuitem';
 923     label?: string;
 924     items: CardItemSpec[];
 925     onSetup?: (api: CardMenuItemInstanceApi) => (api: CardMenuItemInstanceApi) => void;
 926     onAction?: (api: CardMenuItemInstanceApi) => void;
 927 }
 928 interface SeparatorMenuItemSpec {
 929     type?: 'separator';
 930     text?: string;
 931 }
 932 declare type ColumnTypes$1 = number | 'auto';
 933 declare type SeparatorItemSpec = SeparatorMenuItemSpec;
 934 interface AutocompleterItemSpec {
 935     type?: 'autocompleteitem';
 936     value: string;
 937     text?: string;
 938     icon?: string;
 939     meta?: Record<string, any>;
 940 }
 941 declare type AutocompleterContents = SeparatorItemSpec | AutocompleterItemSpec | CardMenuItemSpec;
 942 interface AutocompleterSpec {
 943     type?: 'autocompleter';
 944     ch: string;
 945     minChars?: number;
 946     columns?: ColumnTypes$1;
 947     matches?: (rng: Range, text: string, pattern: string) => boolean;
 948     fetch: (pattern: string, maxResults: number, fetchOptions: Record<string, any>) => Promise<AutocompleterContents[]>;
 949     onAction: (autocompleterApi: AutocompleterInstanceApi, rng: Range, value: string, meta: Record<string, any>) => void;
 950     maxResults?: number;
 951     highlightOn?: string[];
 952 }
 953 interface AutocompleterInstanceApi {
 954     hide: () => void;
 955     reload: (fetchOptions: Record<string, any>) => void;
 956 }
 957 declare type ContextPosition = 'node' | 'selection' | 'line';
 958 declare type ContextScope = 'node' | 'editor';
 959 interface ContextBarSpec {
 960     predicate?: (elem: Element) => boolean;
 961     position?: ContextPosition;
 962     scope?: ContextScope;
 963 }
 964 interface BaseToolbarButtonSpec<I extends BaseToolbarButtonInstanceApi> {
 965     disabled?: boolean;
 966     tooltip?: string;
 967     icon?: string;
 968     text?: string;
 969     onSetup?: (api: I) => (api: I) => void;
 970 }
 971 interface BaseToolbarButtonInstanceApi {
 972     isDisabled: () => boolean;
 973     setDisabled: (state: boolean) => void;
 974 }
 975 interface ToolbarButtonSpec extends BaseToolbarButtonSpec<ToolbarButtonInstanceApi> {
 976     type?: 'button';
 977     onAction: (api: ToolbarButtonInstanceApi) => void;
 978 }
 979 interface ToolbarButtonInstanceApi extends BaseToolbarButtonInstanceApi {
 980 }
 981 interface BaseToolbarToggleButtonSpec<I extends BaseToolbarButtonInstanceApi> extends BaseToolbarButtonSpec<I> {
 982     active?: boolean;
 983 }
 984 interface BaseToolbarToggleButtonInstanceApi extends BaseToolbarButtonInstanceApi {
 985     isActive: () => boolean;
 986     setActive: (state: boolean) => void;
 987 }
 988 interface ToolbarToggleButtonSpec extends BaseToolbarToggleButtonSpec<ToolbarToggleButtonInstanceApi> {
 989     type?: 'togglebutton';
 990     onAction: (api: ToolbarToggleButtonInstanceApi) => void;
 991 }
 992 interface ToolbarToggleButtonInstanceApi extends BaseToolbarToggleButtonInstanceApi {
 993 }
 994 interface ContextFormLaunchButtonApi extends BaseToolbarButtonSpec<BaseToolbarButtonInstanceApi> {
 995     type: 'contextformbutton';
 996 }
 997 interface ContextFormLaunchToggleButtonSpec extends BaseToolbarToggleButtonSpec<BaseToolbarToggleButtonInstanceApi> {
 998     type: 'contextformtogglebutton';
 999 }
1000 interface ContextFormButtonInstanceApi extends BaseToolbarButtonInstanceApi {
1001 }
1002 interface ContextFormToggleButtonInstanceApi extends BaseToolbarToggleButtonInstanceApi {
1003 }
1004 interface ContextFormButtonSpec extends BaseToolbarButtonSpec<ContextFormButtonInstanceApi> {
1005     type?: 'contextformbutton';
1006     primary?: boolean;
1007     onAction: (formApi: ContextFormInstanceApi, api: ContextFormButtonInstanceApi) => void;
1008 }
1009 interface ContextFormToggleButtonSpec extends BaseToolbarToggleButtonSpec<ContextFormToggleButtonInstanceApi> {
1010     type?: 'contextformtogglebutton';
1011     onAction: (formApi: ContextFormInstanceApi, buttonApi: ContextFormToggleButtonInstanceApi) => void;
1012     primary?: boolean;
1013 }
1014 interface ContextFormInstanceApi {
1015     hide: () => void;
1016     getValue: () => string;
1017 }
1018 interface ContextFormSpec extends ContextBarSpec {
1019     type?: 'contextform';
1020     initValue?: () => string;
1021     label?: string;
1022     launch?: ContextFormLaunchButtonApi | ContextFormLaunchToggleButtonSpec;
1023     commands: Array<ContextFormToggleButtonSpec | ContextFormButtonSpec>;
1024 }
1025 interface ContextToolbarSpec extends ContextBarSpec {
1026     type?: 'contexttoolbar';
1027     items: string;
1028 }
1029 interface ChoiceMenuItemSpec extends CommonMenuItemSpec {
1030     type?: 'choiceitem';
1031     icon?: string;
1032 }
1033 interface ChoiceMenuItemInstanceApi extends CommonMenuItemInstanceApi {
1034     isActive: () => boolean;
1035     setActive: (state: boolean) => void;
1036 }
1037 interface ContextMenuItem extends CommonMenuItemSpec {
1038     text: string;
1039     icon?: string;
1040     type?: 'item';
1041     onAction: () => void;
1042 }
1043 interface ContextSubMenu extends CommonMenuItemSpec {
1044     type: 'submenu';
1045     text: string;
1046     icon?: string;
1047     getSubmenuItems: () => string | Array<ContextMenuContents>;
1048 }
1049 declare type ContextMenuContents = string | ContextMenuItem | SeparatorMenuItemSpec | ContextSubMenu;
1050 interface ContextMenuApi {
1051     update: (element: Element) => string | Array<ContextMenuContents>;
1052 }
1053 interface FancyActionArgsMap {
1054     'inserttable': {
1055         numRows: number;
1056         numColumns: number;
1057     };
1058     'colorswatch': {
1059         value: string;
1060     };
1061 }
1062 interface BaseFancyMenuItemSpec<T extends keyof FancyActionArgsMap> {
1063     type: 'fancymenuitem';
1064     fancytype: T;
1065     initData?: Record<string, unknown>;
1066     onAction?: (data: FancyActionArgsMap[T]) => void;
1067 }
1068 interface InsertTableMenuItemSpec extends BaseFancyMenuItemSpec<'inserttable'> {
1069     fancytype: 'inserttable';
1070     initData?: {};
1071 }
1072 interface ColorSwatchMenuItemSpec extends BaseFancyMenuItemSpec<'colorswatch'> {
1073     fancytype: 'colorswatch';
1074     initData?: {
1075         allowCustomColors?: boolean;
1076         colors: ChoiceMenuItemSpec[];
1077     };
1078 }
1079 declare type FancyMenuItemSpec = InsertTableMenuItemSpec | ColorSwatchMenuItemSpec;
1080 interface MenuItemSpec extends CommonMenuItemSpec {
1081     type?: 'menuitem';
1082     icon?: string;
1083     onSetup?: (api: MenuItemInstanceApi) => (api: MenuItemInstanceApi) => void;
1084     onAction?: (api: MenuItemInstanceApi) => void;
1085 }
1086 interface MenuItemInstanceApi extends CommonMenuItemInstanceApi {
1087 }
1088 declare type NestedMenuItemContents = string | MenuItemSpec | NestedMenuItemSpec | ToggleMenuItemSpec | SeparatorMenuItemSpec | FancyMenuItemSpec;
1089 interface NestedMenuItemSpec extends CommonMenuItemSpec {
1090     type?: 'nestedmenuitem';
1091     icon?: string;
1092     getSubmenuItems: () => string | Array<NestedMenuItemContents>;
1093     onSetup?: (api: NestedMenuItemInstanceApi) => (api: NestedMenuItemInstanceApi) => void;
1094 }
1095 interface NestedMenuItemInstanceApi extends CommonMenuItemInstanceApi {
1096 }
1097 interface ToggleMenuItemSpec extends CommonMenuItemSpec {
1098     type?: 'togglemenuitem';
1099     icon?: string;
1100     active?: boolean;
1101     onSetup?: (api: ToggleMenuItemInstanceApi) => void;
1102     onAction: (api: ToggleMenuItemInstanceApi) => void;
1103 }
1104 interface ToggleMenuItemInstanceApi extends CommonMenuItemInstanceApi {
1105     isActive: () => boolean;
1106     setActive: (state: boolean) => void;
1107 }
1108 type PublicDialog_d_AlertBannerSpec = AlertBannerSpec;
1109 type PublicDialog_d_BarSpec = BarSpec;
1110 type PublicDialog_d_BodyComponentSpec = BodyComponentSpec;
1111 type PublicDialog_d_ButtonSpec = ButtonSpec;
1112 type PublicDialog_d_CheckboxSpec = CheckboxSpec;
1113 type PublicDialog_d_CollectionSpec = CollectionSpec;
1114 type PublicDialog_d_ColorInputSpec = ColorInputSpec;
1115 type PublicDialog_d_ColorPickerSpec = ColorPickerSpec;
1116 type PublicDialog_d_CustomEditorSpec = CustomEditorSpec;
1117 type PublicDialog_d_CustomEditorInit = CustomEditorInit;
1118 type PublicDialog_d_CustomEditorInitFn = CustomEditorInitFn;
1119 type PublicDialog_d_DialogData = DialogData;
1120 type PublicDialog_d_DialogSize = DialogSize;
1121 type PublicDialog_d_DialogSpec<_0> = DialogSpec<_0>;
1122 type PublicDialog_d_DialogInstanceApi<_0> = DialogInstanceApi<_0>;
1123 type PublicDialog_d_DialogFooterButtonSpec = DialogFooterButtonSpec;
1124 type PublicDialog_d_DialogActionDetails = DialogActionDetails;
1125 type PublicDialog_d_DialogChangeDetails<_0> = DialogChangeDetails<_0>;
1126 type PublicDialog_d_DialogTabChangeDetails = DialogTabChangeDetails;
1127 type PublicDialog_d_DropZoneSpec = DropZoneSpec;
1128 type PublicDialog_d_GridSpec = GridSpec;
1129 type PublicDialog_d_HtmlPanelSpec = HtmlPanelSpec;
1130 type PublicDialog_d_IframeSpec = IframeSpec;
1131 type PublicDialog_d_ImageToolsSpec = ImageToolsSpec;
1132 type PublicDialog_d_InputSpec = InputSpec;
1133 type PublicDialog_d_LabelSpec = LabelSpec;
1134 type PublicDialog_d_ListBoxSpec = ListBoxSpec;
1135 type PublicDialog_d_ListBoxItemSpec = ListBoxItemSpec;
1136 type PublicDialog_d_ListBoxNestedItemSpec = ListBoxNestedItemSpec;
1137 type PublicDialog_d_ListBoxSingleItemSpec = ListBoxSingleItemSpec;
1138 type PublicDialog_d_PanelSpec = PanelSpec;
1139 type PublicDialog_d_SelectBoxSpec = SelectBoxSpec;
1140 type PublicDialog_d_SelectBoxItemSpec = SelectBoxItemSpec;
1141 type PublicDialog_d_SizeInputSpec = SizeInputSpec;
1142 type PublicDialog_d_TableSpec = TableSpec;
1143 type PublicDialog_d_TabSpec = TabSpec;
1144 type PublicDialog_d_TabPanelSpec = TabPanelSpec;
1145 type PublicDialog_d_TextAreaSpec = TextAreaSpec;
1146 type PublicDialog_d_UrlInputSpec = UrlInputSpec;
1147 type PublicDialog_d_UrlDialogSpec = UrlDialogSpec;
1148 type PublicDialog_d_UrlDialogFooterButtonSpec = UrlDialogFooterButtonSpec;
1149 type PublicDialog_d_UrlDialogInstanceApi = UrlDialogInstanceApi;
1150 type PublicDialog_d_UrlDialogActionDetails = UrlDialogActionDetails;
1151 type PublicDialog_d_UrlDialogMessage = UrlDialogMessage;
1152 declare namespace PublicDialog_d {
1153     export { PublicDialog_d_AlertBannerSpec as AlertBannerSpec, PublicDialog_d_BarSpec as BarSpec, PublicDialog_d_BodyComponentSpec as BodyComponentSpec, PublicDialog_d_ButtonSpec as ButtonSpec, PublicDialog_d_CheckboxSpec as CheckboxSpec, PublicDialog_d_CollectionSpec as CollectionSpec, PublicDialog_d_ColorInputSpec as ColorInputSpec, PublicDialog_d_ColorPickerSpec as ColorPickerSpec, PublicDialog_d_CustomEditorSpec as CustomEditorSpec, PublicDialog_d_CustomEditorInit as CustomEditorInit, PublicDialog_d_CustomEditorInitFn as CustomEditorInitFn, PublicDialog_d_DialogData as DialogData, PublicDialog_d_DialogSize as DialogSize, PublicDialog_d_DialogSpec as DialogSpec, PublicDialog_d_DialogInstanceApi as DialogInstanceApi, PublicDialog_d_DialogFooterButtonSpec as DialogFooterButtonSpec, PublicDialog_d_DialogActionDetails as DialogActionDetails, PublicDialog_d_DialogChangeDetails as DialogChangeDetails, PublicDialog_d_DialogTabChangeDetails as DialogTabChangeDetails, PublicDialog_d_DropZoneSpec as DropZoneSpec, PublicDialog_d_GridSpec as GridSpec, PublicDialog_d_HtmlPanelSpec as HtmlPanelSpec, PublicDialog_d_IframeSpec as IframeSpec, PublicDialog_d_ImageToolsSpec as ImageToolsSpec, PublicDialog_d_InputSpec as InputSpec, PublicDialog_d_LabelSpec as LabelSpec, PublicDialog_d_ListBoxSpec as ListBoxSpec, PublicDialog_d_ListBoxItemSpec as ListBoxItemSpec, PublicDialog_d_ListBoxNestedItemSpec as ListBoxNestedItemSpec, PublicDialog_d_ListBoxSingleItemSpec as ListBoxSingleItemSpec, PublicDialog_d_PanelSpec as PanelSpec, PublicDialog_d_SelectBoxSpec as SelectBoxSpec, PublicDialog_d_SelectBoxItemSpec as SelectBoxItemSpec, PublicDialog_d_SizeInputSpec as SizeInputSpec, PublicDialog_d_TableSpec as TableSpec, PublicDialog_d_TabSpec as TabSpec, PublicDialog_d_TabPanelSpec as TabPanelSpec, PublicDialog_d_TextAreaSpec as TextAreaSpec, PublicDialog_d_UrlInputSpec as UrlInputSpec, PublicDialog_d_UrlDialogSpec as UrlDialogSpec, PublicDialog_d_UrlDialogFooterButtonSpec as UrlDialogFooterButtonSpec, PublicDialog_d_UrlDialogInstanceApi as UrlDialogInstanceApi, PublicDialog_d_UrlDialogActionDetails as UrlDialogActionDetails, PublicDialog_d_UrlDialogMessage as UrlDialogMessage, };
1154 }
1155 type PublicInlineContent_d_AutocompleterSpec = AutocompleterSpec;
1156 type PublicInlineContent_d_AutocompleterItemSpec = AutocompleterItemSpec;
1157 type PublicInlineContent_d_AutocompleterContents = AutocompleterContents;
1158 type PublicInlineContent_d_AutocompleterInstanceApi = AutocompleterInstanceApi;
1159 type PublicInlineContent_d_ContextPosition = ContextPosition;
1160 type PublicInlineContent_d_ContextScope = ContextScope;
1161 type PublicInlineContent_d_ContextFormSpec = ContextFormSpec;
1162 type PublicInlineContent_d_ContextFormInstanceApi = ContextFormInstanceApi;
1163 type PublicInlineContent_d_ContextFormButtonSpec = ContextFormButtonSpec;
1164 type PublicInlineContent_d_ContextFormButtonInstanceApi = ContextFormButtonInstanceApi;
1165 type PublicInlineContent_d_ContextFormToggleButtonSpec = ContextFormToggleButtonSpec;
1166 type PublicInlineContent_d_ContextFormToggleButtonInstanceApi = ContextFormToggleButtonInstanceApi;
1167 type PublicInlineContent_d_ContextToolbarSpec = ContextToolbarSpec;
1168 type PublicInlineContent_d_SeparatorItemSpec = SeparatorItemSpec;
1169 declare namespace PublicInlineContent_d {
1170     export { PublicInlineContent_d_AutocompleterSpec as AutocompleterSpec, PublicInlineContent_d_AutocompleterItemSpec as AutocompleterItemSpec, PublicInlineContent_d_AutocompleterContents as AutocompleterContents, PublicInlineContent_d_AutocompleterInstanceApi as AutocompleterInstanceApi, PublicInlineContent_d_ContextPosition as ContextPosition, PublicInlineContent_d_ContextScope as ContextScope, PublicInlineContent_d_ContextFormSpec as ContextFormSpec, PublicInlineContent_d_ContextFormInstanceApi as ContextFormInstanceApi, PublicInlineContent_d_ContextFormButtonSpec as ContextFormButtonSpec, PublicInlineContent_d_ContextFormButtonInstanceApi as ContextFormButtonInstanceApi, PublicInlineContent_d_ContextFormToggleButtonSpec as ContextFormToggleButtonSpec, PublicInlineContent_d_ContextFormToggleButtonInstanceApi as ContextFormToggleButtonInstanceApi, PublicInlineContent_d_ContextToolbarSpec as ContextToolbarSpec, PublicInlineContent_d_SeparatorItemSpec as SeparatorItemSpec, };
1171 }
1172 type PublicMenu_d_MenuItemSpec = MenuItemSpec;
1173 type PublicMenu_d_MenuItemInstanceApi = MenuItemInstanceApi;
1174 type PublicMenu_d_NestedMenuItemContents = NestedMenuItemContents;
1175 type PublicMenu_d_NestedMenuItemSpec = NestedMenuItemSpec;
1176 type PublicMenu_d_NestedMenuItemInstanceApi = NestedMenuItemInstanceApi;
1177 type PublicMenu_d_FancyMenuItemSpec = FancyMenuItemSpec;
1178 type PublicMenu_d_ColorSwatchMenuItemSpec = ColorSwatchMenuItemSpec;
1179 type PublicMenu_d_InsertTableMenuItemSpec = InsertTableMenuItemSpec;
1180 type PublicMenu_d_ToggleMenuItemSpec = ToggleMenuItemSpec;
1181 type PublicMenu_d_ToggleMenuItemInstanceApi = ToggleMenuItemInstanceApi;
1182 type PublicMenu_d_ChoiceMenuItemSpec = ChoiceMenuItemSpec;
1183 type PublicMenu_d_ChoiceMenuItemInstanceApi = ChoiceMenuItemInstanceApi;
1184 type PublicMenu_d_SeparatorMenuItemSpec = SeparatorMenuItemSpec;
1185 type PublicMenu_d_ContextMenuApi = ContextMenuApi;
1186 type PublicMenu_d_ContextMenuContents = ContextMenuContents;
1187 type PublicMenu_d_ContextMenuItem = ContextMenuItem;
1188 type PublicMenu_d_ContextSubMenu = ContextSubMenu;
1189 type PublicMenu_d_CardMenuItemSpec = CardMenuItemSpec;
1190 type PublicMenu_d_CardMenuItemInstanceApi = CardMenuItemInstanceApi;
1191 type PublicMenu_d_CardItemSpec = CardItemSpec;
1192 type PublicMenu_d_CardContainerSpec = CardContainerSpec;
1193 type PublicMenu_d_CardImageSpec = CardImageSpec;
1194 type PublicMenu_d_CardTextSpec = CardTextSpec;
1195 declare namespace PublicMenu_d {
1196     export { PublicMenu_d_MenuItemSpec as MenuItemSpec, PublicMenu_d_MenuItemInstanceApi as MenuItemInstanceApi, PublicMenu_d_NestedMenuItemContents as NestedMenuItemContents, PublicMenu_d_NestedMenuItemSpec as NestedMenuItemSpec, PublicMenu_d_NestedMenuItemInstanceApi as NestedMenuItemInstanceApi, PublicMenu_d_FancyMenuItemSpec as FancyMenuItemSpec, PublicMenu_d_ColorSwatchMenuItemSpec as ColorSwatchMenuItemSpec, PublicMenu_d_InsertTableMenuItemSpec as InsertTableMenuItemSpec, PublicMenu_d_ToggleMenuItemSpec as ToggleMenuItemSpec, PublicMenu_d_ToggleMenuItemInstanceApi as ToggleMenuItemInstanceApi, PublicMenu_d_ChoiceMenuItemSpec as ChoiceMenuItemSpec, PublicMenu_d_ChoiceMenuItemInstanceApi as ChoiceMenuItemInstanceApi, PublicMenu_d_SeparatorMenuItemSpec as SeparatorMenuItemSpec, PublicMenu_d_ContextMenuApi as ContextMenuApi, PublicMenu_d_ContextMenuContents as ContextMenuContents, PublicMenu_d_ContextMenuItem as ContextMenuItem, PublicMenu_d_ContextSubMenu as ContextSubMenu, PublicMenu_d_CardMenuItemSpec as CardMenuItemSpec, PublicMenu_d_CardMenuItemInstanceApi as CardMenuItemInstanceApi, PublicMenu_d_CardItemSpec as CardItemSpec, PublicMenu_d_CardContainerSpec as CardContainerSpec, PublicMenu_d_CardImageSpec as CardImageSpec, PublicMenu_d_CardTextSpec as CardTextSpec, };
1197 }
1198 interface SidebarInstanceApi {
1199     element: () => HTMLElement;
1200 }
1201 interface SidebarSpec {
1202     icon?: string;
1203     tooltip?: string;
1204     onShow?: (api: SidebarInstanceApi) => void;
1205     onSetup?: (api: SidebarInstanceApi) => (api: SidebarInstanceApi) => void;
1206     onHide?: (api: SidebarInstanceApi) => void;
1207 }
1208 type PublicSidebar_d_SidebarSpec = SidebarSpec;
1209 type PublicSidebar_d_SidebarInstanceApi = SidebarInstanceApi;
1210 declare namespace PublicSidebar_d {
1211     export { PublicSidebar_d_SidebarSpec as SidebarSpec, PublicSidebar_d_SidebarInstanceApi as SidebarInstanceApi, };
1212 }
1213 interface ToolbarGroupSetting {
1214     name: string;
1215     items: string[];
1216 }
1217 declare type ToolbarConfig = string | ToolbarGroupSetting[];
1218 interface GroupToolbarButtonInstanceApi extends BaseToolbarButtonInstanceApi {
1219 }
1220 interface GroupToolbarButtonSpec extends BaseToolbarButtonSpec<GroupToolbarButtonInstanceApi> {
1221     type?: 'grouptoolbarbutton';
1222     items?: ToolbarConfig;
1223 }
1224 declare type MenuButtonItemTypes = NestedMenuItemContents;
1225 declare type SuccessCallback$1 = (menu: string | MenuButtonItemTypes[]) => void;
1226 interface BaseMenuButtonSpec {
1227     text?: string;
1228     tooltip?: string;
1229     icon?: string;
1230     fetch: (success: SuccessCallback$1) => void;
1231     onSetup?: (api: BaseMenuButtonInstanceApi) => (api: BaseMenuButtonInstanceApi) => void;
1232 }
1233 interface BaseMenuButtonInstanceApi {
1234     isDisabled: () => boolean;
1235     setDisabled: (state: boolean) => void;
1236     isActive: () => boolean;
1237     setActive: (state: boolean) => void;
1238 }
1239 interface ToolbarMenuButtonSpec extends BaseMenuButtonSpec {
1240     type?: 'menubutton';
1241     onSetup?: (api: ToolbarMenuButtonInstanceApi) => (api: ToolbarMenuButtonInstanceApi) => void;
1242 }
1243 interface ToolbarMenuButtonInstanceApi extends BaseMenuButtonInstanceApi {
1244 }
1245 declare type ToolbarSplitButtonItemTypes = ChoiceMenuItemSpec | SeparatorMenuItemSpec;
1246 declare type SuccessCallback = (menu: ToolbarSplitButtonItemTypes[]) => void;
1247 declare type SelectPredicate = (value: string) => boolean;
1248 declare type PresetTypes = 'color' | 'normal' | 'listpreview';
1249 declare type ColumnTypes = number | 'auto';
1250 interface ToolbarSplitButtonSpec {
1251     type?: 'splitbutton';
1252     tooltip?: string;
1253     icon?: string;
1254     text?: string;
1255     select?: SelectPredicate;
1256     presets?: PresetTypes;
1257     columns?: ColumnTypes;
1258     fetch: (success: SuccessCallback) => void;
1259     onSetup?: (api: ToolbarSplitButtonInstanceApi) => (api: ToolbarSplitButtonInstanceApi) => void;
1260     onAction: (api: ToolbarSplitButtonInstanceApi) => void;
1261     onItemAction: (api: ToolbarSplitButtonInstanceApi, value: string) => void;
1262 }
1263 interface ToolbarSplitButtonInstanceApi {
1264     isDisabled: () => boolean;
1265     setDisabled: (state: boolean) => void;
1266     setIconFill: (id: string, value: string) => void;
1267     setIconStroke: (id: string, value: string) => void;
1268     isActive: () => boolean;
1269     setActive: (state: boolean) => void;
1270 }
1271 type PublicToolbar_d_ToolbarButtonSpec = ToolbarButtonSpec;
1272 type PublicToolbar_d_ToolbarButtonInstanceApi = ToolbarButtonInstanceApi;
1273 type PublicToolbar_d_ToolbarSplitButtonSpec = ToolbarSplitButtonSpec;
1274 type PublicToolbar_d_ToolbarSplitButtonInstanceApi = ToolbarSplitButtonInstanceApi;
1275 type PublicToolbar_d_ToolbarMenuButtonSpec = ToolbarMenuButtonSpec;
1276 type PublicToolbar_d_ToolbarMenuButtonInstanceApi = ToolbarMenuButtonInstanceApi;
1277 type PublicToolbar_d_ToolbarToggleButtonSpec = ToolbarToggleButtonSpec;
1278 type PublicToolbar_d_ToolbarToggleButtonInstanceApi = ToolbarToggleButtonInstanceApi;
1279 type PublicToolbar_d_GroupToolbarButtonSpec = GroupToolbarButtonSpec;
1280 type PublicToolbar_d_GroupToolbarButtonInstanceApi = GroupToolbarButtonInstanceApi;
1281 declare namespace PublicToolbar_d {
1282     export { PublicToolbar_d_ToolbarButtonSpec as ToolbarButtonSpec, PublicToolbar_d_ToolbarButtonInstanceApi as ToolbarButtonInstanceApi, PublicToolbar_d_ToolbarSplitButtonSpec as ToolbarSplitButtonSpec, PublicToolbar_d_ToolbarSplitButtonInstanceApi as ToolbarSplitButtonInstanceApi, PublicToolbar_d_ToolbarMenuButtonSpec as ToolbarMenuButtonSpec, PublicToolbar_d_ToolbarMenuButtonInstanceApi as ToolbarMenuButtonInstanceApi, PublicToolbar_d_ToolbarToggleButtonSpec as ToolbarToggleButtonSpec, PublicToolbar_d_ToolbarToggleButtonInstanceApi as ToolbarToggleButtonInstanceApi, PublicToolbar_d_GroupToolbarButtonSpec as GroupToolbarButtonSpec, PublicToolbar_d_GroupToolbarButtonInstanceApi as GroupToolbarButtonInstanceApi, };
1283 }
1284 interface Registry$1 {
1285     addButton: (name: string, spec: ToolbarButtonSpec) => void;
1286     addGroupToolbarButton: (name: string, spec: GroupToolbarButtonSpec) => void;
1287     addToggleButton: (name: string, spec: ToolbarToggleButtonSpec) => void;
1288     addMenuButton: (name: string, spec: ToolbarMenuButtonSpec) => void;
1289     addSplitButton: (name: string, spec: ToolbarSplitButtonSpec) => void;
1290     addMenuItem: (name: string, spec: MenuItemSpec) => void;
1291     addNestedMenuItem: (name: string, spec: NestedMenuItemSpec) => void;
1292     addToggleMenuItem: (name: string, spec: ToggleMenuItemSpec) => void;
1293     addContextMenu: (name: string, spec: ContextMenuApi) => void;
1294     addContextToolbar: (name: string, spec: ContextToolbarSpec) => void;
1295     addContextForm: (name: string, spec: ContextFormSpec) => void;
1296     addIcon: (name: string, svgData: string) => void;
1297     addAutocompleter: (name: string, spec: AutocompleterSpec) => void;
1298     addSidebar: (name: string, spec: SidebarSpec) => void;
1299     getAll: () => {
1300         buttons: Record<string, ToolbarButtonSpec | GroupToolbarButtonSpec | ToolbarMenuButtonSpec | ToolbarSplitButtonSpec | ToolbarToggleButtonSpec>;
1301         menuItems: Record<string, MenuItemSpec | NestedMenuItemSpec | ToggleMenuItemSpec>;
1302         popups: Record<string, AutocompleterSpec>;
1303         contextMenus: Record<string, ContextMenuApi>;
1304         contextToolbars: Record<string, ContextToolbarSpec | ContextFormSpec>;
1305         icons: Record<string, string>;
1306         sidebars: Record<string, SidebarSpec>;
1307     };
1308 }
1309 interface StyleSheetLoaderSettings {
1310     maxLoadTime?: number;
1311     contentCssCors?: boolean;
1312     referrerPolicy?: ReferrerPolicy;
1313 }
1314 interface StyleSheetLoader {
1315     load: (url: string, success: () => void, failure?: () => void) => void;
1316     loadAll: (urls: string[], success: (urls: string[]) => void, failure: (urls: string[]) => void) => void;
1317     unload: (url: string) => void;
1318     unloadAll: (urls: string[]) => void;
1319     _setReferrerPolicy: (referrerPolicy: ReferrerPolicy) => void;
1320 }
1321 declare type Registry = Registry$1;
1322 interface EditorUiApi {
1323     show: () => void;
1324     hide: () => void;
1325     enable: () => void;
1326     disable: () => void;
1327     isDisabled: () => boolean;
1328 }
1329 interface EditorUi extends EditorUiApi {
1330     registry: Registry;
1331     styleSheetLoader: StyleSheetLoader;
1332 }
1333 type Ui_d_Registry = Registry;
1334 type Ui_d_EditorUiApi = EditorUiApi;
1335 type Ui_d_EditorUi = EditorUi;
1336 declare namespace Ui_d {
1337     export { Ui_d_Registry as Registry, PublicDialog_d as Dialog, PublicInlineContent_d as InlineContent, PublicMenu_d as Menu, PublicSidebar_d as Sidebar, PublicToolbar_d as Toolbar, Ui_d_EditorUiApi as EditorUiApi, Ui_d_EditorUi as EditorUi, };
1338 }
1339 declare type EntityEncoding = 'named' | 'numeric' | 'raw' | 'named,numeric' | 'named+numeric' | 'numeric,named' | 'numeric+named';
1340 interface ContentLanguage {
1341     readonly title: string;
1342     readonly code: string;
1343     readonly customCode?: string;
1344 }
1345 declare type ThemeInitFunc = (editor: Editor, elm: HTMLElement) => {
1346     editorContainer: HTMLElement;
1347     iframeContainer: HTMLElement;
1348     height?: number;
1349     iframeHeight?: number;
1350     api?: EditorUiApi;
1351 };
1352 declare type SetupCallback = (editor: Editor) => void;
1353 declare type FilePickerCallback = (callback: Function, value: any, meta: Record<string, any>) => void;
1354 declare type FilePickerValidationStatus = 'valid' | 'unknown' | 'invalid' | 'none';
1355 declare type FilePickerValidationCallback = (info: {
1356     type: string;
1357     url: string;
1358 }, callback: (validation: {
1359     status: FilePickerValidationStatus;
1360     message: string;
1361 }) => void) => void;
1362 declare type URLConverter = (url: string, name: string, elm?: HTMLElement) => string;
1363 declare type URLConverterCallback = (url: string, node: Node, on_save: boolean, name: string) => void;
1364 interface ToolbarGroup {
1365     name?: string;
1366     items: string[];
1367 }
1368 declare type ToolbarMode = 'floating' | 'sliding' | 'scrolling' | 'wrap';
1369 interface BaseEditorSettings {
1370     add_form_submit_trigger?: boolean;
1371     add_unload_trigger?: boolean;
1372     allow_conditional_comments?: boolean;
1373     allow_html_data_urls?: boolean;
1374     allow_html_in_named_anchor?: boolean;
1375     allow_script_urls?: boolean;
1376     allow_svg_data_urls?: boolean;
1377     allow_unsafe_link_target?: boolean;
1378     anchor_bottom?: false | string;
1379     anchor_top?: false | string;
1380     auto_focus?: string | true;
1381     automatic_uploads?: boolean;
1382     base_url?: string;
1383     block_formats?: string;
1384     block_unsupported_drop?: boolean;
1385     body_id?: string;
1386     body_class?: string;
1387     br_in_pre?: boolean;
1388     br_newline_selector?: string;
1389     browser_spellcheck?: boolean;
1390     branding?: boolean;
1391     cache_suffix?: string;
1392     color_cols?: number;
1393     color_map?: string[];
1394     content_css?: boolean | string | string[];
1395     content_css_cors?: boolean;
1396     content_security_policy?: string;
1397     content_style?: string;
1398     deprecation_warnings?: boolean;
1399     font_css?: string | string[];
1400     content_langs?: ContentLanguage[];
1401     contextmenu?: string | false;
1402     contextmenu_never_use_native?: boolean;
1403     convert_fonts_to_spans?: boolean;
1404     convert_urls?: boolean;
1405     custom_colors?: boolean;
1406     custom_elements?: string;
1407     custom_ui_selector?: string;
1408     custom_undo_redo_levels?: number;
1409     directionality?: 'ltr' | 'rtl';
1410     doctype?: string;
1411     document_base_url?: string;
1412     element_format?: 'xhtml' | 'html';
1413     elementpath?: boolean;
1414     encoding?: string;
1415     end_container_on_empty_block?: boolean;
1416     entities?: string;
1417     entity_encoding?: EntityEncoding;
1418     extended_valid_elements?: string;
1419     event_root?: string;
1420     file_picker_callback?: FilePickerCallback;
1421     file_picker_types?: string;
1422     file_picker_validator_handler?: FilePickerValidationCallback;
1423     fix_list_elements?: boolean;
1424     fixed_toolbar_container?: string;
1425     fixed_toolbar_container_target?: HTMLElement;
1426     font_formats?: string;
1427     font_size_classes?: string;
1428     font_size_legacy_values?: string;
1429     font_size_style_values?: string;
1430     fontsize_formats?: string;
1431     force_hex_style_colors?: boolean;
1432     forced_root_block?: boolean | string;
1433     forced_root_block_attrs?: Record<string, string>;
1434     formats?: Formats;
1435     gecko_spellcheck?: boolean;
1436     height?: number | string;
1437     hidden_input?: boolean;
1438     icons?: string;
1439     icons_url?: string;
1440     id?: string;
1441     iframe_aria_text?: string;
1442     images_dataimg_filter?: (imgElm: HTMLImageElement) => boolean;
1443     images_file_types?: string;
1444     images_replace_blob_uris?: boolean;
1445     images_reuse_filename?: boolean;
1446     images_upload_base_path?: string;
1447     images_upload_credentials?: boolean;
1448     images_upload_handler?: UploadHandler;
1449     images_upload_url?: string;
1450     indent?: boolean;
1451     indent_after?: string;
1452     indent_before?: string;
1453     indent_use_margin?: boolean;
1454     indentation?: string;
1455     init_instance_callback?: SetupCallback;
1456     inline?: boolean;
1457     inline_boundaries?: boolean;
1458     inline_boundaries_selector?: string;
1459     inline_styles?: boolean;
1460     invalid_elements?: string;
1461     invalid_styles?: string | Record<string, string>;
1462     keep_styles?: boolean;
1463     language?: string;
1464     language_load?: boolean;
1465     language_url?: string;
1466     lineheight_formats?: string;
1467     max_height?: number;
1468     max_width?: number;
1469     menu?: Record<string, {
1470         title: string;
1471         items: string;
1472     }>;
1473     menubar?: boolean | string;
1474     min_height?: number;
1475     min_width?: number;
1476     no_newline_selector?: string;
1477     nowrap?: boolean;
1478     object_resizing?: boolean | string;
1479     padd_empty_with_br?: boolean;
1480     placeholder?: string;
1481     preserve_cdata?: boolean;
1482     preview_styles?: boolean | string;
1483     protect?: RegExp[];
1484     readonly?: boolean;
1485     referrer_policy?: ReferrerPolicy;
1486     relative_urls?: boolean;
1487     remove_script_host?: boolean;
1488     remove_trailing_brs?: boolean;
1489     removed_menuitems?: string;
1490     resize?: boolean | 'both';
1491     resize_img_proportional?: boolean;
1492     root_name?: string;
1493     schema?: SchemaType;
1494     selector?: string;
1495     setup?: SetupCallback;
1496     skin?: boolean | string;
1497     skin_url?: string;
1498     statusbar?: boolean;
1499     style_formats?: AllowedFormat[];
1500     style_formats_autohide?: boolean;
1501     style_formats_merge?: boolean;
1502     submit_patch?: boolean;
1503     suffix?: string;
1504     target?: HTMLElement;
1505     theme?: string | ThemeInitFunc;
1506     theme_url?: string;
1507     toolbar?: boolean | string | string[] | Array<ToolbarGroup>;
1508     toolbar1?: string;
1509     toolbar2?: string;
1510     toolbar3?: string;
1511     toolbar4?: string;
1512     toolbar5?: string;
1513     toolbar6?: string;
1514     toolbar7?: string;
1515     toolbar8?: string;
1516     toolbar9?: string;
1517     toolbar_mode?: ToolbarMode;
1518     typeahead_urls?: boolean;
1519     url_converter?: URLConverter;
1520     url_converter_scope?: any;
1521     urlconverter_callback?: string | URLConverterCallback;
1522     valid_children?: string;
1523     valid_classes?: string | Record<string, string>;
1524     valid_elements?: string;
1525     valid_styles?: string | Record<string, string>;
1526     verify_html?: boolean;
1527     visual?: boolean;
1528     visual_anchor_class?: string;
1529     visual_table_class?: string;
1530     width?: number | string;
1531     toolbar_drawer?: false | 'floating' | 'sliding' | 'scrolling';
1532     editor_deselector?: string;
1533     editor_selector?: string;
1534     elements?: string;
1535     filepicker_validator_handler?: FilePickerValidationCallback;
1536     mode?: 'exact' | 'textareas' | 'specific_textareas';
1537     types?: Record<string, any>[];
1538     block_elements?: string;
1539     boolean_attributes?: string;
1540     move_caret_before_on_enter_elements?: string;
1541     non_empty_elements?: string;
1542     self_closing_elements?: string;
1543     short_ended_elements?: string;
1544     text_block_elements?: string;
1545     text_inline_elements?: string;
1546     whitespace_elements?: string;
1547     special?: string;
1548     disable_nodechange?: boolean;
1549     forced_plugins?: string | string[];
1550     plugin_base_urls?: Record<string, string>;
1551     service_message?: string;
1552     validate?: boolean;
1553     [key: string]: any;
1554 }
1555 interface RawEditorSettings extends BaseEditorSettings {
1556     external_plugins?: Record<string, string>;
1557     mobile?: RawEditorSettings;
1558     plugins?: string | string[];
1559 }
1560 interface EditorSettings extends BaseEditorSettings {
1561     external_plugins: Record<string, string>;
1562     plugins: string;
1563 }
1564 interface ParamTypeMap {
1565     'hash': Record<string, string>;
1566     'string': string;
1567     'number': number;
1568     'boolean': boolean;
1569     'string[]': string[];
1570     'array': any[];
1571 }
1572 interface BlobInfoImagePair {
1573     image: HTMLImageElement;
1574     blobInfo: BlobInfo;
1575 }
1576 declare class NodeChange {
1577     private readonly editor;
1578     private lastPath;
1579     constructor(editor: Editor);
1580     nodeChanged(args?: any): void;
1581     private isSameElementPath;
1582 }
1583 interface SelectionOverrides {
1584     showCaret: (direction: number, node: Element, before: boolean, scrollIntoView?: boolean) => Range | null;
1585     showBlockCaretContainer: (blockCaretContainer: Element) => void;
1586     hideFakeCaret: () => void;
1587     destroy: () => void;
1588 }
1589 interface Quirks {
1590     refreshContentEditable(): void;
1591     isHidden(): boolean;
1592 }
1593 declare type DecoratorData = Record<string, any>;
1594 declare type Decorator = (uid: string, data: DecoratorData) => {
1595     attributes?: {};
1596     classes?: string[];
1597 };
1598 declare type AnnotationListener = (state: boolean, name: string, data?: {
1599     uid: string;
1600     nodes: any[];
1601 }) => void;
1602 declare type AnnotationListenerApi = AnnotationListener;
1603 interface AnnotatorSettings {
1604     decorate: Decorator;
1605     persistent?: boolean;
1606 }
1607 interface Annotator {
1608     register: (name: string, settings: AnnotatorSettings) => void;
1609     annotate: (name: string, data: DecoratorData) => void;
1610     annotationChanged: (name: string, f: AnnotationListenerApi) => void;
1611     remove: (name: string) => void;
1612     getAll: (name: string) => Record<string, Element[]>;
1613 }
1614 interface GeomRect {
1615     readonly x: number;
1616     readonly y: number;
1617     readonly w: number;
1618     readonly h: number;
1619 }
1620 interface Rect {
1621     inflate: (rect: GeomRect, w: number, h: number) => GeomRect;
1622     relativePosition: (rect: GeomRect, targetRect: GeomRect, rel: string) => GeomRect;
1623     findBestRelativePosition: (rect: GeomRect, targetRect: GeomRect, constrainRect: GeomRect, rels: string[]) => string | null;
1624     intersect: (rect: GeomRect, cropRect: GeomRect) => GeomRect | null;
1625     clamp: (rect: GeomRect, clampRect: GeomRect, fixedSize?: boolean) => GeomRect;
1626     create: (x: number, y: number, w: number, h: number) => GeomRect;
1627     fromClientRect: (clientRect: DOMRect) => GeomRect;
1628 }
1629 interface StyleMap {
1630     [s: string]: string | number;
1631 }
1632 interface StylesSettings {
1633     allow_script_urls?: boolean;
1634     allow_svg_data_urls?: boolean;
1635     url_converter?: URLConverter;
1636     url_converter_scope?: any;
1637 }
1638 interface Styles {
1639     toHex: (color: string) => string;
1640     parse: (css: string) => Record<string, string>;
1641     serialize: (styles: StyleMap, elementName?: string) => string;
1642 }
1643 interface DOMUtilsSettings {
1644     schema: Schema;
1645     url_converter: URLConverter;
1646     url_converter_scope: any;
1647     ownEvents: boolean;
1648     keep_values: boolean;
1649     hex_colors: boolean;
1650     update_styles: boolean;
1651     root_element: HTMLElement;
1652     collect: Function;
1653     onSetAttrib: Function;
1654     contentCssCors: boolean;
1655     referrerPolicy: ReferrerPolicy;
1656 }
1657 declare type Target = Node | Window;
1658 declare type RunArguments<T extends Node = Node> = string | T | Array<string | T>;
1659 declare type BoundEvent = [
1660     Target,
1661     string,
1662     EventUtilsCallback<any>,
1663     any
1664 ];
1665 declare type Callback<K extends string> = EventUtilsCallback<MappedEvent<HTMLElementEventMap, K>>;
1666 interface DOMUtils {
1667     doc: Document;
1668     settings: Partial<DOMUtilsSettings>;
1669     win: Window;
1670     files: Record<string, boolean>;
1671     stdMode: boolean;
1672     boxModel: boolean;
1673     styleSheetLoader: StyleSheetLoader;
1674     boundEvents: BoundEvent[];
1675     styles: Styles;
1676     schema: Schema;
1677     events: EventUtils;
1678     root: Node;
1679     $: DomQueryConstructor;
1680     $$: {
1681         <T extends Node>(elm: T | T[] | DomQuery<T>): DomQuery<T>;
1682         (elm: string): DomQuery<Node>;
1683     };
1684     isBlock: (node: string | Node) => boolean;
1685     clone: (node: Node, deep: boolean) => Node;
1686     getRoot: () => HTMLElement;
1687     getViewPort: (argWin?: Window) => GeomRect;
1688     getRect: (elm: string | HTMLElement) => GeomRect;
1689     getSize: (elm: string | HTMLElement) => {
1690         w: number;
1691         h: number;
1692     };
1693     getParent: {
1694         <K extends keyof HTMLElementTagNameMap>(node: string | Node, selector: K, root?: Node): HTMLElementTagNameMap[K] | null;
1695         <T extends HTMLElement>(node: string | Node, selector: (node: HTMLElement) => node is T, root?: Node): T | null;
1696         <T extends Element = Element>(node: string | Node, selector?: string | ((node: HTMLElement) => boolean | void), root?: Node): T | null;
1697     };
1698     getParents: {
1699         <K extends keyof HTMLElementTagNameMap>(elm: string | Node, selector: K, root?: Node, collect?: boolean): Array<HTMLElementTagNameMap[K]>;
1700         <T extends HTMLElement>(node: string | Node, selector: (node: HTMLElement) => node is T, root?: Node): T[];
1701         <T extends Element = Element>(elm: string | Node, selector?: string | ((node: HTMLElement) => boolean | void), root?: Node, collect?: boolean): T[];
1702     };
1703     get: (elm: string | Node) => HTMLElement | null;
1704     getNext: (node: Node, selector: string | ((node: Node) => boolean)) => Node | null;
1705     getPrev: (node: Node, selector: string | ((node: Node) => boolean)) => Node | null;
1706     select: {
1707         <K extends keyof HTMLElementTagNameMap>(selector: K, scope?: string | Node): Array<HTMLElementTagNameMap[K]>;
1708         <T extends HTMLElement = HTMLElement>(selector: string, scope?: string | Node): T[];
1709     };
1710     is: (elm: Node | Node[], selector: string) => boolean;
1711     add: (parentElm: RunArguments, name: string | Node, attrs?: Record<string, string | boolean | number>, html?: string | Node, create?: boolean) => HTMLElement;
1712     create: {
1713         <K extends keyof HTMLElementTagNameMap>(name: K, attrs?: Record<string, string | boolean | number>, html?: string | Node): HTMLElementTagNameMap[K];
1714         (name: string, attrs?: Record<string, string | boolean | number>, html?: string | Node): HTMLElement;
1715     };
1716     createHTML: (name: string, attrs?: Record<string, string>, html?: string) => string;
1717     createFragment: (html?: string) => DocumentFragment;
1718     remove: <T extends Node>(node: string | T | T[] | DomQuery<T>, keepChildren?: boolean) => T | T[];
1719     setStyle: {
1720         (elm: string | Node | Node[], name: string, value: string | number | null): void;
1721         (elm: string | Node | Node[], styles: StyleMap): void;
1722     };
1723     getStyle: (elm: string | Node, name: string, computed?: boolean) => string;
1724     setStyles: (elm: string | Node | Node[], stylesArg: StyleMap) => void;
1725     removeAllAttribs: (e: RunArguments<Element>) => void;
1726     setAttrib: (elm: string | Node | Node[], name: string, value: string | boolean | number | null) => void;
1727     setAttribs: (elm: string | Node | Node[], attrs: Record<string, string | boolean | number | null>) => void;
1728     getAttrib: (elm: string | Node, name: string, defaultVal?: string) => string;
1729     getPos: (elm: string | Node, rootElm?: Node) => {
1730         x: number;
1731         y: number;
1732     };
1733     parseStyle: (cssText: string) => Record<string, string>;
1734     serializeStyle: (stylesArg: StyleMap, name?: string) => string;
1735     addStyle: (cssText: string) => void;
1736     loadCSS: (url: string) => void;
1737     addClass: (elm: string | Node | Node[], cls: string) => void;
1738     removeClass: (elm: string | Node | Node[], cls: string) => void;
1739     hasClass: (elm: string | Node, cls: string) => boolean;
1740     toggleClass: (elm: string | Node | Node[], cls: string, state?: boolean) => void;
1741     show: (elm: string | Node | Node[]) => void;
1742     hide: (elm: string | Node | Node[]) => void;
1743     isHidden: (elm: string | Node) => boolean;
1744     uniqueId: (prefix?: string) => string;
1745     setHTML: (elm: string | Node | Node[], html: string) => void;
1746     getOuterHTML: (elm: string | Node) => string;
1747     setOuterHTML: (elm: string | Node | Node[], html: string) => void;
1748     decode: (text: string) => string;
1749     encode: (text: string) => string;
1750     insertAfter: {
1751         <T extends Node>(node: T | T[], reference: string | Node): T;
1752         <T extends Node>(node: RunArguments<T>, reference: string | Node): false | T;
1753     };
1754     replace: {
1755         <T extends Node>(newElm: Node, oldElm: T | T[], keepChildren?: boolean): T;
1756         <T extends Node>(newElm: Node, oldElm: RunArguments<T>, keepChildren?: boolean): false | T;
1757     };
1758     rename: {
1759         <K extends keyof HTMLElementTagNameMap>(elm: Element, name: K): HTMLElementTagNameMap[K];
1760         (elm: Element, name: string): Element;
1761     };
1762     findCommonAncestor: (a: Node, b: Node) => Node;
1763     toHex: (rgbVal: string) => string;
1764     run<R, T extends Node>(this: DOMUtils, elm: T | T[], func: (node: T) => R, scope?: any): R;
1765     run<R, T extends Node>(this: DOMUtils, elm: RunArguments<T>, func: (node: T) => R, scope?: any): false | R;
1766     getAttribs: (elm: string | Node) => NamedNodeMap | Attr[];
1767     isEmpty: (node: Node, elements?: Record<string, any>) => boolean;
1768     createRng: () => Range;
1769     nodeIndex: (node: Node, normalized?: boolean) => number;
1770     split: {
1771         <T extends Node>(parentElm: Node, splitElm: Node, replacementElm: T): T;
1772         <T extends Node>(parentElm: Node, splitElm: T): T;
1773     };
1774     bind: {
1775         <K extends string>(target: Target, name: K, func: Callback<K>, scope?: any): Callback<K>;
1776         <K extends string>(target: Target[], name: K, func: Callback<K>, scope?: any): Callback<K>[];
1777     };
1778     unbind: {
1779         <K extends string>(target: Target, name?: K, func?: EventUtilsCallback<MappedEvent<HTMLElementEventMap, K>>): EventUtils;
1780         <K extends string>(target: Target[], name?: K, func?: EventUtilsCallback<MappedEvent<HTMLElementEventMap, K>>): EventUtils[];
1781     };
1782     fire: (target: Node | Window, name: string, evt?: {}) => EventUtils;
1783     getContentEditable: (node: Node) => string | null;
1784     getContentEditableParent: (node: Node) => string | null;
1785     destroy: () => void;
1786     isChildOf: (node: Node, parent: Node) => boolean;
1787     dumpRng: (r: Range) => string;
1788 }
1789 interface ClientRect {
1790     left: number;
1791     top: number;
1792     bottom: number;
1793     right: number;
1794     width: number;
1795     height: number;
1796 }
1797 interface GetSelectionContentArgs extends GetContentArgs {
1798     selection?: boolean;
1799     contextual?: boolean;
1800 }
1801 interface SelectionSetContentArgs extends SetContentArgs {
1802     selection?: boolean;
1803 }
1804 interface BookmarkManager {
1805     getBookmark: (type: number, normalized?: boolean) => Bookmark;
1806     moveToBookmark: (bookmark: Bookmark) => void;
1807 }
1808 interface ControlSelection {
1809     isResizable: (elm: Element) => boolean;
1810     showResizeRect: (elm: Element) => void;
1811     hideResizeRect: () => void;
1812     updateResizeRect: (evt: EditorEvent<any>) => void;
1813     destroy: () => void;
1814 }
1815 interface ParserArgs {
1816     getInner?: boolean | number;
1817     forced_root_block?: boolean | string;
1818     context?: string;
1819     isRootContent?: boolean;
1820     format?: string;
1821     invalid?: boolean;
1822     no_events?: boolean;
1823     [key: string]: any;
1824 }
1825 declare type ParserFilterCallback = (nodes: AstNode[], name: string, args: ParserArgs) => void;
1826 interface ParserFilter {
1827     name: string;
1828     callbacks: ParserFilterCallback[];
1829 }
1830 interface DomParserSettings {
1831     allow_html_data_urls?: boolean;
1832     allow_svg_data_urls?: boolean;
1833     allow_conditional_comments?: boolean;
1834     allow_html_in_named_anchor?: boolean;
1835     allow_script_urls?: boolean;
1836     allow_unsafe_link_target?: boolean;
1837     convert_fonts_to_spans?: boolean;
1838     fix_list_elements?: boolean;
1839     font_size_legacy_values?: string;
1840     forced_root_block?: boolean | string;
1841     forced_root_block_attrs?: Record<string, string>;
1842     padd_empty_with_br?: boolean;
1843     preserve_cdata?: boolean;
1844     remove_trailing_brs?: boolean;
1845     root_name?: string;
1846     validate?: boolean;
1847     inline_styles?: boolean;
1848     blob_cache?: BlobCache;
1849     document?: Document;
1850     images_dataimg_filter?: (img: HTMLImageElement) => boolean;
1851 }
1852 interface DomParser {
1853     schema: Schema;
1854     addAttributeFilter: (name: string, callback: (nodes: AstNode[], name: string, args: ParserArgs) => void) => void;
1855     getAttributeFilters: () => ParserFilter[];
1856     addNodeFilter: (name: string, callback: (nodes: AstNode[], name: string, args: ParserArgs) => void) => void;
1857     getNodeFilters: () => ParserFilter[];
1858     filterNode: (node: AstNode) => AstNode;
1859     parse: (html: string, args?: ParserArgs) => AstNode;
1860 }
1861 interface WriterSettings {
1862     element_format?: 'xhtml' | 'html';
1863     entities?: string;
1864     entity_encoding?: EntityEncoding;
1865     indent?: boolean;
1866     indent_after?: string;
1867     indent_before?: string;
1868 }
1869 declare type Attributes = Array<{
1870     name: string;
1871     value: string;
1872 }>;
1873 interface Writer {
1874     cdata: (text: string) => void;
1875     comment: (text: string) => void;
1876     doctype: (text: string) => void;
1877     end: (name: string) => void;
1878     getContent: () => string;
1879     pi: (name: string, text?: string) => void;
1880     reset: () => void;
1881     start: (name: string, attrs?: Attributes, empty?: boolean) => void;
1882     text: (text: string, raw?: boolean) => void;
1883 }
1884 interface HtmlSerializerSettings extends WriterSettings {
1885     inner?: boolean;
1886     validate?: boolean;
1887 }
1888 interface HtmlSerializer {
1889     serialize: (node: AstNode) => string;
1890 }
1891 interface DomSerializerSettings extends DomParserSettings, WriterSettings, SchemaSettings, HtmlSerializerSettings {
1892     url_converter?: URLConverter;
1893     url_converter_scope?: {};
1894 }
1895 interface DomSerializerImpl {
1896     schema: Schema;
1897     addNodeFilter: (name: string, callback: (nodes: AstNode[], name: string, args: ParserArgs) => void) => void;
1898     addAttributeFilter: (name: string, callback: (nodes: AstNode[], name: string, args: ParserArgs) => void) => void;
1899     getNodeFilters: () => ParserFilter[];
1900     getAttributeFilters: () => ParserFilter[];
1901     serialize: {
1902         (node: Element, parserArgs: {
1903             format: 'tree';
1904         } & ParserArgs): AstNode;
1905         (node: Element, parserArgs?: ParserArgs): string;
1906     };
1907     addRules: (rules: string) => void;
1908     setRules: (rules: string) => void;
1909     addTempAttr: (name: string) => void;
1910     getTempAttrs: () => string[];
1911 }
1912 interface DomSerializer extends DomSerializerImpl {
1913 }
1914 interface EditorSelection {
1915     bookmarkManager: BookmarkManager;
1916     controlSelection: ControlSelection;
1917     dom: DOMUtils;
1918     win: Window;
1919     serializer: DomSerializer;
1920     editor: Editor;
1921     collapse: (toStart?: boolean) => void;
1922     setCursorLocation: {
1923         (node: Node, offset: number): void;
1924         (): void;
1925     };
1926     getContent: {
1927         (args: {
1928             format: 'tree';
1929         } & GetSelectionContentArgs): AstNode;
1930         (args?: GetSelectionContentArgs): string;
1931     };
1932     setContent: (content: string, args?: SelectionSetContentArgs) => void;
1933     getBookmark: (type?: number, normalized?: boolean) => Bookmark;
1934     moveToBookmark: (bookmark: Bookmark) => void;
1935     select: (node: Node, content?: boolean) => Node;
1936     isCollapsed: () => boolean;
1937     isForward: () => boolean;
1938     setNode: (elm: Element) => Element;
1939     getNode: () => Element;
1940     getSel: () => Selection | null;
1941     setRng: (rng: Range, forward?: boolean) => void;
1942     getRng: () => Range;
1943     getStart: (real?: boolean) => Element;
1944     getEnd: (real?: boolean) => Element;
1945     getSelectedBlocks: (startElm?: Element, endElm?: Element) => Element[];
1946     normalize: () => Range;
1947     selectorChanged: (selector: string, callback: (active: boolean, args: {
1948         node: Node;
1949         selector: String;
1950         parents: Element[];
1951     }) => void) => EditorSelection;
1952     selectorChangedWithUnbind: (selector: string, callback: (active: boolean, args: {
1953         node: Node;
1954         selector: String;
1955         parents: Element[];
1956     }) => void) => {
1957         unbind: () => void;
1958     };
1959     getScrollContainer: () => HTMLElement;
1960     scrollIntoView: (elm?: HTMLElement, alignToTop?: boolean) => void;
1961     placeCaretAt: (clientX: number, clientY: number) => void;
1962     getBoundingClientRect: () => ClientRect | DOMRect;
1963     destroy: () => void;
1964 }
1965 declare type EditorCommandCallback = (ui: boolean, value: any, args: any) => void;
1966 declare type EditorCommandsCallback = (command: string, ui: boolean, value: any, args: any) => void;
1967 interface Commands {
1968     state: Record<string, (command: string) => boolean>;
1969     exec: Record<string, EditorCommandsCallback>;
1970     value: Record<string, (command: string) => string>;
1971 }
1972 interface EditorCommandsConstructor {
1973     readonly prototype: EditorCommands;
1974     new (editor: Editor): EditorCommands;
1975 }
1976 declare class EditorCommands {
1977     private readonly editor;
1978     private selectionBookmark;
1979     private commands;
1980     constructor(editor: Editor);
1981     execCommand(command: string, ui?: boolean, value?: any, args?: any): boolean;
1982     queryCommandState(command: string): boolean;
1983     queryCommandValue(command: string): string;
1984     addCommands<K extends keyof Commands>(commandList: Commands[K], type: K): void;
1985     addCommands(commandList: Record<string, EditorCommandsCallback>): void;
1986     addCommand(command: string, callback: EditorCommandCallback, scope?: any): void;
1987     queryCommandSupported(command: string): boolean;
1988     addQueryStateHandler(command: string, callback: () => boolean, scope?: any): void;
1989     addQueryValueHandler(command: string, callback: () => string, scope?: any): void;
1990     hasCustomCommand(command: string): boolean;
1991     private execNativeCommand;
1992     private isFormatMatch;
1993     private toggleFormat;
1994     private storeSelection;
1995     private restoreSelection;
1996     private setupCommands;
1997 }
1998 interface WindowParams {
1999     readonly inline?: 'cursor' | 'toolbar';
2000     readonly ariaAttrs?: boolean;
2001 }
2002 declare type InstanceApi<T> = UrlDialogInstanceApi | DialogInstanceApi<T>;
2003 interface WindowManagerImpl {
2004     open: <T>(config: DialogSpec<T>, params: WindowParams, closeWindow: (dialog: DialogInstanceApi<T>) => void) => DialogInstanceApi<T>;
2005     openUrl: (config: UrlDialogSpec, closeWindow: (dialog: UrlDialogInstanceApi) => void) => UrlDialogInstanceApi;
2006     alert: (message: string, callback: () => void) => void;
2007     confirm: (message: string, callback: (state: boolean) => void) => void;
2008     close: (dialog: InstanceApi<any>) => void;
2009 }
2010 interface WindowManager {
2011     open: <T>(config: DialogSpec<T>, params?: WindowParams) => DialogInstanceApi<T>;
2012     openUrl: (config: UrlDialogSpec) => UrlDialogInstanceApi;
2013     alert: (message: string, callback?: () => void, scope?: any) => void;
2014     confirm: (message: string, callback?: (state: boolean) => void, scope?: any) => void;
2015     close: () => void;
2016 }
2017 interface ExecCommandEvent {
2018     command: string;
2019     ui?: boolean;
2020     value?: any;
2021 }
2022 declare type GetContentEvent = GetContentArgs & {
2023     source_view?: boolean;
2024     selection?: boolean;
2025     save?: boolean;
2026 };
2027 declare type SetContentEvent = SetContentArgs & {
2028     source_view?: boolean;
2029     paste?: boolean;
2030     selection?: boolean;
2031 };
2032 interface NewBlockEvent {
2033     newBlock: Element;
2034 }
2035 interface NodeChangeEvent {
2036     element: Element;
2037     parents: Node[];
2038     selectionChange?: boolean;
2039     initial?: boolean;
2040 }
2041 interface FormatEvent {
2042     format: string;
2043     vars?: FormatVars;
2044     node?: Node | RangeLikeObject;
2045 }
2046 interface ObjectResizeEvent {
2047     target: HTMLElement;
2048     width: number;
2049     height: number;
2050     origin: string;
2051 }
2052 interface ObjectSelectedEvent {
2053     target: Node;
2054     targetClone?: Node;
2055 }
2056 interface ScrollIntoViewEvent {
2057     elm: HTMLElement;
2058     alignToTop: boolean;
2059 }
2060 interface SetSelectionRangeEvent {
2061     range: Range;
2062     forward: boolean;
2063 }
2064 interface ShowCaretEvent {
2065     target: Node;
2066     direction: number;
2067     before: boolean;
2068 }
2069 interface SwitchModeEvent {
2070     mode: string;
2071 }
2072 interface AddUndoEvent {
2073     level: UndoLevel;
2074     lastLevel: UndoLevel;
2075     originalEvent: Event;
2076 }
2077 interface UndoRedoEvent {
2078     level: UndoLevel;
2079 }
2080 interface WindowEvent<T extends DialogData> {
2081     dialog: InstanceApi<T>;
2082 }
2083 interface ProgressStateEvent {
2084     state: boolean;
2085     time?: number;
2086 }
2087 interface AfterProgressStateEvent {
2088     state: boolean;
2089 }
2090 interface PlaceholderToggleEvent {
2091     state: boolean;
2092 }
2093 interface LoadErrorEvent {
2094     message: string;
2095 }
2096 interface PreProcessEvent extends ParserArgs {
2097     node: Element;
2098 }
2099 interface PostProcessEvent extends ParserArgs {
2100     content: string;
2101 }
2102 interface EditorEventMap extends Omit<NativeEventMap, 'blur' | 'focus'> {
2103     'activate': {
2104         relatedTarget: Editor;
2105     };
2106     'deactivate': {
2107         relatedTarget: Editor;
2108     };
2109     'focus': {
2110         blurredEditor: Editor;
2111     };
2112     'blur': {
2113         focusedEditor: Editor;
2114     };
2115     'resize': UIEvent;
2116     'scroll': UIEvent;
2117     'detach': {};
2118     'remove': {};
2119     'init': {};
2120     'ScrollIntoView': ScrollIntoViewEvent;
2121     'AfterScrollIntoView': ScrollIntoViewEvent;
2122     'ObjectResized': ObjectResizeEvent;
2123     'ObjectResizeStart': ObjectResizeEvent;
2124     'SwitchMode': SwitchModeEvent;
2125     'ScrollWindow': UIEvent;
2126     'ResizeWindow': UIEvent;
2127     'SkinLoaded': {};
2128     'SkinLoadError': LoadErrorEvent;
2129     'PluginLoadError': LoadErrorEvent;
2130     'IconsLoadError': LoadErrorEvent;
2131     'LanguageLoadError': LoadErrorEvent;
2132     'BeforeExecCommand': ExecCommandEvent;
2133     'ExecCommand': ExecCommandEvent;
2134     'NodeChange': NodeChangeEvent;
2135     'FormatApply': FormatEvent;
2136     'FormatRemove': FormatEvent;
2137     'ShowCaret': ShowCaretEvent;
2138     'SelectionChange': {};
2139     'ObjectSelected': ObjectSelectedEvent;
2140     'BeforeObjectSelected': ObjectSelectedEvent;
2141     'GetSelectionRange': {
2142         range: Range;
2143     };
2144     'SetSelectionRange': SetSelectionRangeEvent;
2145     'AfterSetSelectionRange': SetSelectionRangeEvent;
2146     'BeforeGetContent': GetContentEvent;
2147     'GetContent': GetContentEvent;
2148     'BeforeSetContent': SetContentEvent;
2149     'SetContent': SetContentEvent;
2150     'LoadContent': {};
2151     'PreviewFormats': {};
2152     'AfterPreviewFormats': {};
2153     'ScriptsLoaded': {};
2154     'PreInit': {};
2155     'PostRender': {};
2156     'NewBlock': NewBlockEvent;
2157     'ClearUndos': {};
2158     'TypingUndo': {};
2159     'Redo': UndoRedoEvent;
2160     'Undo': UndoRedoEvent;
2161     'BeforeAddUndo': AddUndoEvent;
2162     'AddUndo': AddUndoEvent;
2163     'CloseWindow': WindowEvent<any>;
2164     'OpenWindow': WindowEvent<any>;
2165     'ProgressState': ProgressStateEvent;
2166     'AfterProgressState': AfterProgressStateEvent;
2167     'PlaceholderToggle': PlaceholderToggleEvent;
2168     'tap': TouchEvent;
2169     'longpress': TouchEvent;
2170     'longpresscancel': {};
2171     'PreProcess': PreProcessEvent;
2172     'PostProcess': PostProcessEvent;
2173 }
2174 interface EditorManagerEventMap {
2175     'AddEditor': {
2176         editor: Editor;
2177     };
2178     'RemoveEditor': {
2179         editor: Editor;
2180     };
2181     'BeforeUnload': {
2182         returnValue: any;
2183     };
2184 }
2185 type EventTypes_d_ExecCommandEvent = ExecCommandEvent;
2186 type EventTypes_d_GetContentEvent = GetContentEvent;
2187 type EventTypes_d_SetContentEvent = SetContentEvent;
2188 type EventTypes_d_NewBlockEvent = NewBlockEvent;
2189 type EventTypes_d_NodeChangeEvent = NodeChangeEvent;
2190 type EventTypes_d_FormatEvent = FormatEvent;
2191 type EventTypes_d_ObjectResizeEvent = ObjectResizeEvent;
2192 type EventTypes_d_ObjectSelectedEvent = ObjectSelectedEvent;
2193 type EventTypes_d_ScrollIntoViewEvent = ScrollIntoViewEvent;
2194 type EventTypes_d_SetSelectionRangeEvent = SetSelectionRangeEvent;
2195 type EventTypes_d_ShowCaretEvent = ShowCaretEvent;
2196 type EventTypes_d_SwitchModeEvent = SwitchModeEvent;
2197 type EventTypes_d_AddUndoEvent = AddUndoEvent;
2198 type EventTypes_d_UndoRedoEvent = UndoRedoEvent;
2199 type EventTypes_d_WindowEvent<_0> = WindowEvent<_0>;
2200 type EventTypes_d_ProgressStateEvent = ProgressStateEvent;
2201 type EventTypes_d_AfterProgressStateEvent = AfterProgressStateEvent;
2202 type EventTypes_d_PlaceholderToggleEvent = PlaceholderToggleEvent;
2203 type EventTypes_d_LoadErrorEvent = LoadErrorEvent;
2204 type EventTypes_d_PreProcessEvent = PreProcessEvent;
2205 type EventTypes_d_PostProcessEvent = PostProcessEvent;
2206 type EventTypes_d_EditorEventMap = EditorEventMap;
2207 type EventTypes_d_EditorManagerEventMap = EditorManagerEventMap;
2208 declare namespace EventTypes_d {
2209     export { EventTypes_d_ExecCommandEvent as ExecCommandEvent, EventTypes_d_GetContentEvent as GetContentEvent, EventTypes_d_SetContentEvent as SetContentEvent, EventTypes_d_NewBlockEvent as NewBlockEvent, EventTypes_d_NodeChangeEvent as NodeChangeEvent, EventTypes_d_FormatEvent as FormatEvent, EventTypes_d_ObjectResizeEvent as ObjectResizeEvent, EventTypes_d_ObjectSelectedEvent as ObjectSelectedEvent, EventTypes_d_ScrollIntoViewEvent as ScrollIntoViewEvent, EventTypes_d_SetSelectionRangeEvent as SetSelectionRangeEvent, EventTypes_d_ShowCaretEvent as ShowCaretEvent, EventTypes_d_SwitchModeEvent as SwitchModeEvent, EventTypes_d_AddUndoEvent as AddUndoEvent, EventTypes_d_UndoRedoEvent as UndoRedoEvent, EventTypes_d_WindowEvent as WindowEvent, EventTypes_d_ProgressStateEvent as ProgressStateEvent, EventTypes_d_AfterProgressStateEvent as AfterProgressStateEvent, EventTypes_d_PlaceholderToggleEvent as PlaceholderToggleEvent, EventTypes_d_LoadErrorEvent as LoadErrorEvent, EventTypes_d_PreProcessEvent as PreProcessEvent, EventTypes_d_PostProcessEvent as PostProcessEvent, EventTypes_d_EditorEventMap as EditorEventMap, EventTypes_d_EditorManagerEventMap as EditorManagerEventMap, };
2210 }
2211 interface RawString {
2212     raw: string;
2213 }
2214 declare type Primitive = string | number | boolean | Record<string | number, any> | Function;
2215 declare type TokenisedString = [
2216     string,
2217     ...Primitive[]
2218 ];
2219 declare type Untranslated = Primitive | TokenisedString | RawString;
2220 declare type TranslatedString = string;
2221 interface I18n {
2222     getData: () => Record<string, Record<string, string>>;
2223     setCode: (newCode: string) => void;
2224     getCode: () => string;
2225     add: (code: string, items: Record<string, string>) => void;
2226     translate: (text: Untranslated) => TranslatedString;
2227     isRtl: () => boolean;
2228     hasCode: (code: string) => boolean;
2229 }
2230 interface Observable<T> {
2231     fire<K extends string, U extends MappedEvent<T, K>>(name: K, args?: U, bubble?: boolean): EditorEvent<U>;
2232     on<K extends string>(name: K, callback: (event: EditorEvent<MappedEvent<T, K>>) => void, prepend?: boolean): EventDispatcher<T>;
2233     off<K extends string>(name?: K, callback?: (event: EditorEvent<MappedEvent<T, K>>) => void): EventDispatcher<T>;
2234     once<K extends string>(name: K, callback: (event: EditorEvent<MappedEvent<T, K>>) => void): EventDispatcher<T>;
2235     hasEventListeners(name: string): boolean;
2236 }
2237 interface URISettings {
2238     base_uri?: URI;
2239 }
2240 interface URIConstructor {
2241     readonly prototype: URI;
2242     new (url: string, settings?: URISettings): URI;
2243     getDocumentBaseUrl: (loc: {
2244         protocol: string;
2245         host?: string;
2246         href?: string;
2247         pathname?: string;
2248     }) => string;
2249     parseDataUri: (uri: string) => {
2250         type: string;
2251         data: string;
2252     };
2253 }
2254 interface SafeUriOptions {
2255     readonly allow_html_data_urls?: boolean;
2256     readonly allow_script_urls?: boolean;
2257     readonly allow_svg_data_urls?: boolean;
2258 }
2259 declare class URI {
2260     static parseDataUri(uri: string): {
2261         type: string;
2262         data: string;
2263     };
2264     static isDomSafe(uri: string, context?: string, options?: SafeUriOptions): boolean;
2265     static getDocumentBaseUrl(loc: {
2266         protocol: string;
2267         host?: string;
2268         href?: string;
2269         pathname?: string;
2270     }): string;
2271     source: string;
2272     protocol: string;
2273     authority: string;
2274     userInfo: string;
2275     user: string;
2276     password: string;
2277     host: string;
2278     port: string;
2279     relative: string;
2280     path: string;
2281     directory: string;
2282     file: string;
2283     query: string;
2284     anchor: string;
2285     settings: URISettings;
2286     constructor(url: string, settings?: URISettings);
2287     setPath(path: string): void;
2288     toRelative(uri: string): string;
2289     toAbsolute(uri: string, noHost?: boolean): string;
2290     isSameOrigin(uri: URI): boolean;
2291     toRelPath(base: string, path: string): string;
2292     toAbsPath(base: string, path: string): string;
2293     getURI(noProtoHost?: boolean): string;
2294 }
2295 interface EditorManager extends Observable<EditorManagerEventMap> {
2296     $: DomQueryConstructor;
2297     defaultSettings: RawEditorSettings;
2298     majorVersion: string;
2299     minorVersion: string;
2300     releaseDate: string;
2301     editors: Editor[];
2302     activeEditor: Editor;
2303     focusedEditor: Editor;
2304     settings: RawEditorSettings;
2305     baseURI: URI;
2306     baseURL: string;
2307     documentBaseURL: string;
2308     i18n: I18n;
2309     suffix: string;
2310     add(this: EditorManager, editor: Editor): Editor;
2311     addI18n: (code: string, item: Record<string, string>) => void;
2312     createEditor(this: EditorManager, id: string, settings: RawEditorSettings): Editor;
2313     execCommand(this: EditorManager, cmd: string, ui: boolean, value: any): boolean;
2314     get(this: EditorManager): Editor[];
2315     get(this: EditorManager, id: number | string): Editor;
2316     init(this: EditorManager, settings: RawEditorSettings): Promise<Editor[]>;
2317     overrideDefaults(this: EditorManager, defaultSettings: Partial<RawEditorSettings>): void;
2318     remove(this: EditorManager): void;
2319     remove(this: EditorManager, selector: string | Editor): Editor | void;
2320     setActive(this: EditorManager, editor: Editor): void;
2321     setup(this: EditorManager): void;
2322     translate: (text: Untranslated) => TranslatedString;
2323     triggerSave: () => void;
2324     _setBaseUrl(this: EditorManager, baseUrl: string): void;
2325 }
2326 interface EditorObservable extends Observable<EditorEventMap> {
2327     bindPendingEventDelegates(this: Editor): void;
2328     toggleNativeEvent(this: Editor, name: string, state: boolean): any;
2329     unbindAllNativeEvents(this: Editor): void;
2330 }
2331 interface UploadResult$1 {
2332     element: HTMLImageElement;
2333     status: boolean;
2334     blobInfo: BlobInfo;
2335     uploadUri: string;
2336 }
2337 declare type UploadCallback = (results: UploadResult$1[]) => void;
2338 interface EditorUpload {
2339     blobCache: BlobCache;
2340     addFilter: (filter: (img: HTMLImageElement) => boolean) => void;
2341     uploadImages: (callback?: UploadCallback) => Promise<UploadResult$1[]>;
2342     uploadImagesAuto: (callback?: UploadCallback) => void | Promise<UploadResult$1[]>;
2343     scanForImages: () => Promise<BlobInfoImagePair[]>;
2344     destroy: () => void;
2345 }
2346 declare type FormatChangeCallback = (state: boolean, data: {
2347     node: Node;
2348     format: string;
2349     parents: any;
2350 }) => void;
2351 interface FormatRegistry {
2352     get: {
2353         (name: string): Format[] | undefined;
2354         (): Record<string, Format[]>;
2355     };
2356     has: (name: string) => boolean;
2357     register: (name: string | Formats, format?: Format[] | Format) => void;
2358     unregister: (name: string) => Formats;
2359 }
2360 interface Formatter extends FormatRegistry {
2361     apply: (name: string, vars?: FormatVars, node?: Node | RangeLikeObject) => void;
2362     remove: (name: string, vars?: FormatVars, node?: Node | Range, similar?: boolean) => void;
2363     toggle: (name: string, vars?: FormatVars, node?: Node) => void;
2364     match: (name: string, vars?: FormatVars, node?: Node, similar?: boolean) => boolean;
2365     closest: (names: string[]) => string | null;
2366     matchAll: (names: string[], vars?: FormatVars) => string[];
2367     matchNode: (node: Node, name: string, vars?: FormatVars, similar?: boolean) => Format | undefined;
2368     canApply: (name: string) => boolean;
2369     formatChanged: (names: string, callback: FormatChangeCallback, similar?: boolean, vars?: FormatVars) => {
2370         unbind: () => void;
2371     };
2372     getCssText: (format: string | Format) => string;
2373 }
2374 interface EditorMode {
2375     isReadOnly: () => boolean;
2376     set: (mode: string) => void;
2377     get: () => string;
2378     register: (mode: string, api: EditorModeApi) => void;
2379 }
2380 interface EditorModeApi {
2381     activate: () => void;
2382     deactivate: () => void;
2383     editorReadOnly: boolean;
2384 }
2385 interface Plugin {
2386     getMetadata?: () => {
2387         name: string;
2388         url: string;
2389     };
2390     [key: string]: any;
2391 }
2392 declare type PluginManager = AddOnManager<Plugin>;
2393 interface ShortcutsConstructor {
2394     readonly prototype: Shortcuts;
2395     new (editor: Editor): Shortcuts;
2396 }
2397 declare type CommandFunc = string | [
2398     string,
2399     boolean,
2400     any
2401 ] | (() => void);
2402 declare class Shortcuts {
2403     private readonly editor;
2404     private readonly shortcuts;
2405     private pendingPatterns;
2406     constructor(editor: Editor);
2407     add(pattern: string, desc: string, cmdFunc: CommandFunc, scope?: any): boolean;
2408     remove(pattern: string): boolean;
2409     private normalizeCommandFunc;
2410     private createShortcut;
2411     private hasModifier;
2412     private isFunctionKey;
2413     private matchShortcut;
2414     private executeShortcutAction;
2415 }
2416 interface Theme {
2417     ui?: any;
2418     inline?: any;
2419     execCommand?: (command: string, ui?: boolean, value?: any) => boolean;
2420     destroy?: () => void;
2421     init?: (editor: Editor, url: string, $: DomQueryConstructor) => void;
2422     renderUI?: () => {
2423         iframeContainer?: HTMLIFrameElement;
2424         editorContainer: HTMLElement;
2425         api?: Partial<EditorUiApi>;
2426     };
2427     getNotificationManagerImpl?: () => NotificationManagerImpl;
2428     getWindowManagerImpl?: () => WindowManagerImpl;
2429 }
2430 declare type ThemeManager = AddOnManager<Theme>;
2431 interface EditorConstructor {
2432     readonly prototype: Editor;
2433     new (id: string, settings: RawEditorSettings, editorManager: EditorManager): Editor;
2434 }
2435 declare class Editor implements EditorObservable {
2436     documentBaseUrl: string;
2437     baseUri: URI;
2438     settings: EditorSettings;
2439     id: string;
2440     plugins: Record<string, Plugin>;
2441     documentBaseURI: URI;
2442     baseURI: URI;
2443     contentCSS: string[];
2444     contentStyles: string[];
2445     ui: EditorUi;
2446     mode: EditorMode;
2447     setMode: (mode: string) => void;
2448     $: DomQueryConstructor;
2449     shortcuts: Shortcuts;
2450     loadedCSS: Record<string, any>;
2451     editorCommands: EditorCommands;
2452     suffix: string;
2453     editorManager: EditorManager;
2454     inline: boolean;
2455     isNotDirty: boolean;
2456     callbackLookup: any;
2457     _nodeChangeDispatcher: NodeChange;
2458     editorUpload: EditorUpload;
2459     annotator: Annotator;
2460     bodyElement: HTMLElement;
2461     bookmark: any;
2462     composing: boolean;
2463     container: HTMLElement;
2464     contentAreaContainer: HTMLElement;
2465     contentDocument: Document;
2466     contentWindow: Window;
2467     delegates: Record<string, (event: any) => void>;
2468     destroyed: boolean;
2469     dom: DOMUtils;
2470     editorContainer: HTMLElement;
2471     eventRoot?: Element;
2472     formatter: Formatter;
2473     formElement: HTMLElement;
2474     formEventDelegate: (e: Event) => void;
2475     hasHiddenInput: boolean;
2476     hasVisual: boolean;
2477     hidden: boolean;
2478     iframeElement: HTMLIFrameElement | null;
2479     iframeHTML: string;
2480     initialized: boolean;
2481     notificationManager: NotificationManager;
2482     orgDisplay: string;
2483     orgVisibility: string;
2484     parser: DomParser;
2485     quirks: Quirks;
2486     readonly: boolean;
2487     removed: boolean;
2488     schema: Schema;
2489     selection: EditorSelection;
2490     serializer: DomSerializer;
2491     startContent: string;
2492     targetElm: HTMLElement;
2493     theme: Theme;
2494     undoManager: UndoManager;
2495     validate: boolean;
2496     windowManager: WindowManager;
2497     _beforeUnload: () => void;
2498     _eventDispatcher: EventDispatcher<NativeEventMap>;
2499     _mceOldSubmit: any;
2500     _pendingNativeEvents: string[];
2501     _selectionOverrides: SelectionOverrides;
2502     _skinLoaded: boolean;
2503     bindPendingEventDelegates: EditorObservable['bindPendingEventDelegates'];
2504     toggleNativeEvent: EditorObservable['toggleNativeEvent'];
2505     unbindAllNativeEvents: EditorObservable['unbindAllNativeEvents'];
2506     fire: EditorObservable['fire'];
2507     on: EditorObservable['on'];
2508     off: EditorObservable['off'];
2509     once: EditorObservable['once'];
2510     hasEventListeners: EditorObservable['hasEventListeners'];
2511     constructor(id: string, settings: RawEditorSettings, editorManager: EditorManager);
2512     render(): void;
2513     focus(skipFocus?: boolean): void;
2514     hasFocus(): boolean;
2515     execCallback(name: string, ...x: any[]): any;
2516     translate(text: Untranslated): TranslatedString;
2517     getParam<K extends keyof ParamTypeMap>(name: string, defaultVal: ParamTypeMap[K], type: K): ParamTypeMap[K];
2518     getParam<K extends keyof EditorSettings>(name: K, defaultVal?: EditorSettings[K], type?: string): EditorSettings[K];
2519     getParam<T>(name: string, defaultVal: T, type?: string): T;
2520     hasPlugin(name: string, loaded?: boolean): boolean;
2521     nodeChanged(args?: any): void;
2522     addCommand(name: string, callback: EditorCommandCallback, scope?: object): void;
2523     addQueryStateHandler(name: string, callback: () => boolean, scope?: any): void;
2524     addQueryValueHandler(name: string, callback: () => string, scope?: any): void;
2525     addShortcut(pattern: string, desc: string, cmdFunc: string | [
2526         string,
2527         boolean,
2528         any
2529     ] | (() => void), scope?: any): void;
2530     execCommand(cmd: string, ui?: boolean, value?: any, args?: any): boolean;
2531     queryCommandState(cmd: string): boolean;
2532     queryCommandValue(cmd: string): string;
2533     queryCommandSupported(cmd: string): boolean;
2534     show(): void;
2535     hide(): void;
2536     isHidden(): boolean;
2537     setProgressState(state: boolean, time?: number): void;
2538     load(args?: any): string;
2539     save(args?: any): string;
2540     setContent(content: string, args?: SetContentArgs): string;
2541     setContent(content: AstNode, args?: SetContentArgs): AstNode;
2542     setContent(content: Content, args?: SetContentArgs): Content;
2543     getContent(args: {
2544         format: 'tree';
2545     } & GetContentArgs): AstNode;
2546     getContent(args?: GetContentArgs): string;
2547     insertContent(content: string, args?: any): void;
2548     resetContent(initialContent?: string): void;
2549     isDirty(): boolean;
2550     setDirty(state: boolean): void;
2551     getContainer(): HTMLElement;
2552     getContentAreaContainer(): HTMLElement;
2553     getElement(): HTMLElement;
2554     getWin(): Window;
2555     getDoc(): Document;
2556     getBody(): HTMLElement;
2557     convertURL(url: string, name: string, elm?: any): string;
2558     addVisual(elm?: HTMLElement): void;
2559     remove(): void;
2560     destroy(automatic?: boolean): void;
2561     uploadImages(callback?: UploadCallback): Promise<UploadResult$1[]>;
2562     _scanForImages(): Promise<BlobInfoImagePair[]>;
2563     addButton(): void;
2564     addSidebar(): void;
2565     addMenuItem(): void;
2566     addContextToolbar(): void;
2567 }
2568 interface UrlObject {
2569     prefix: string;
2570     resource: string;
2571     suffix: string;
2572 }
2573 declare type WaitState = 'added' | 'loaded';
2574 declare type AddOnCallback<T> = (editor: Editor, url: string, $?: DomQueryConstructor) => void | T;
2575 declare type AddOnConstructor<T> = new (editor: Editor, url: string, $?: DomQueryConstructor) => T;
2576 interface AddOnManager<T> {
2577     items: AddOnConstructor<T>[];
2578     urls: Record<string, string>;
2579     lookup: Record<string, {
2580         instance: AddOnConstructor<T>;
2581         dependencies?: string[];
2582     }>;
2583     _listeners: {
2584         name: string;
2585         state: WaitState;
2586         callback: () => void;
2587     }[];
2588     get: (name: string) => AddOnConstructor<T>;
2589     dependencies: (name: string) => string[];
2590     requireLangPack: (name: string, languages: string) => void;
2591     add: (id: string, addOn: AddOnCallback<T>, dependencies?: string[]) => AddOnConstructor<T>;
2592     remove: (name: string) => void;
2593     createUrl: (baseUrl: UrlObject, dep: string | UrlObject) => UrlObject;
2594     addComponents: (pluginName: string, scripts: string[]) => void;
2595     load: (name: string, addOnUrl: string | UrlObject, success?: () => void, scope?: any, failure?: () => void) => void;
2596     waitFor: (name: string, callback: () => void, state?: WaitState) => void;
2597 }
2598 interface RangeUtils {
2599     walk: (rng: Range, callback: (nodes: Node[]) => void) => void;
2600     split: (rng: Range) => RangeLikeObject;
2601     normalize: (rng: Range) => boolean;
2602 }
2603 interface ScriptLoaderSettings {
2604     referrerPolicy?: ReferrerPolicy;
2605 }
2606 interface ScriptLoaderConstructor {
2607     readonly prototype: ScriptLoader;
2608     new (): ScriptLoader;
2609     ScriptLoader: ScriptLoader;
2610 }
2611 declare class ScriptLoader {
2612     static ScriptLoader: ScriptLoader;
2613     private settings;
2614     private states;
2615     private queue;
2616     private scriptLoadedCallbacks;
2617     private queueLoadedCallbacks;
2618     private loading;
2619     constructor(settings?: ScriptLoaderSettings);
2620     _setReferrerPolicy(referrerPolicy: ReferrerPolicy): void;
2621     loadScript(url: string, success?: () => void, failure?: () => void): void;
2622     isDone(url: string): boolean;
2623     markDone(url: string): void;
2624     add(url: string, success?: () => void, scope?: any, failure?: () => void): void;
2625     load(url: string, success?: () => void, scope?: any, failure?: () => void): void;
2626     remove(url: string): void;
2627     loadQueue(success?: () => void, scope?: any, failure?: (urls: string[]) => void): void;
2628     loadScripts(scripts: string[], success?: () => void, scope?: any, failure?: (urls: string[]) => void): void;
2629 }
2630 declare type TextProcessCallback = (node: Text, offset: number, text: string) => number;
2631 interface Spot {
2632     container: Text;
2633     offset: number;
2634 }
2635 interface TextSeeker {
2636     backwards: (node: Node, offset: number, process: TextProcessCallback, root?: Node) => Spot | null;
2637     forwards: (node: Node, offset: number, process: TextProcessCallback, root?: Node) => Spot | null;
2638 }
2639 interface DomTreeWalkerConstructor {
2640     readonly prototype: DomTreeWalker;
2641     new (startNode: Node, rootNode: Node): DomTreeWalker;
2642 }
2643 declare class DomTreeWalker {
2644     private readonly rootNode;
2645     private node;
2646     constructor(startNode: Node, rootNode: Node);
2647     current(): Node;
2648     next(shallow?: boolean): Node;
2649     prev(shallow?: boolean): Node;
2650     prev2(shallow?: boolean): Node;
2651     private findSibling;
2652     private findPreviousNode;
2653 }
2654 interface Version {
2655     major: number;
2656     minor: number;
2657 }
2658 interface Env {
2659     opera: boolean;
2660     webkit: boolean;
2661     ie: false | number;
2662     gecko: boolean;
2663     mac: boolean;
2664     iOS: boolean;
2665     android: boolean;
2666     contentEditable: boolean;
2667     transparentSrc: string;
2668     caretAfter: boolean;
2669     range: boolean;
2670     documentMode: number;
2671     fileApi: boolean;
2672     ceFalse: boolean;
2673     cacheSuffix: any;
2674     container: any;
2675     experimentalShadowDom: boolean;
2676     canHaveCSP: boolean;
2677     desktop: boolean;
2678     windowsPhone: boolean;
2679     browser: {
2680         current: string | undefined;
2681         version: Version;
2682         isEdge: () => boolean;
2683         isChrome: () => boolean;
2684         isIE: () => boolean;
2685         isOpera: () => boolean;
2686         isFirefox: () => boolean;
2687         isSafari: () => boolean;
2688     };
2689     os: {
2690         current: string | undefined;
2691         version: Version;
2692         isWindows: () => boolean;
2693         isiOS: () => boolean;
2694         isAndroid: () => boolean;
2695         isOSX: () => boolean;
2696         isLinux: () => boolean;
2697         isSolaris: () => boolean;
2698         isFreeBSD: () => boolean;
2699         isChromeOS: () => boolean;
2700     };
2701     deviceType: {
2702         isiPad: () => boolean;
2703         isiPhone: () => boolean;
2704         isTablet: () => boolean;
2705         isPhone: () => boolean;
2706         isTouch: () => boolean;
2707         isWebView: () => boolean;
2708         isDesktop: () => boolean;
2709     };
2710 }
2711 interface FocusManager {
2712     isEditorUIElement: (elm: Element) => boolean;
2713 }
2714 interface EntitiesMap {
2715     [name: string]: string;
2716 }
2717 interface Entities {
2718     encodeRaw: (text: string, attr?: boolean) => string;
2719     encodeAllRaw: (text: string) => string;
2720     encodeNumeric: (text: string, attr?: boolean) => string;
2721     encodeNamed: (text: string, attr?: boolean, entities?: EntitiesMap) => string;
2722     getEncodeFunc: (name: string, entities?: EntitiesMap | string) => (text: string, attr?: boolean) => string;
2723     decode: (text: string) => string;
2724 }
2725 declare type AttrList = Array<{
2726     name: string;
2727     value: string;
2728 }> & {
2729     map: Record<string, string>;
2730 };
2731 interface SaxParserSettings {
2732     allow_conditional_comments?: boolean;
2733     allow_html_data_urls?: boolean;
2734     allow_script_urls?: boolean;
2735     allow_svg_data_urls?: boolean;
2736     fix_self_closing?: boolean;
2737     preserve_cdata?: boolean;
2738     remove_internals?: boolean;
2739     self_closing_elements?: Record<string, {}>;
2740     validate?: boolean;
2741     document?: Document;
2742     cdata?: (text: string) => void;
2743     comment?: (text: string) => void;
2744     doctype?: (text: string) => void;
2745     end?: (name: string) => void;
2746     pi?: (name: string, text: string) => void;
2747     start?: (name: string, attrs: AttrList, empty: boolean) => void;
2748     text?: (text: string, raw?: boolean) => void;
2749 }
2750 declare type ParserFormat = 'html' | 'xhtml' | 'xml';
2751 interface SaxParser {
2752     parse: (html: string, format?: ParserFormat) => void;
2753 }
2754 interface IconPack {
2755     icons: Record<string, string>;
2756 }
2757 interface IconManager {
2758     add: (id: string, iconPack: IconPack) => void;
2759     get: (id: string) => IconPack;
2760     has: (id: string) => boolean;
2761 }
2762 interface Resource {
2763     load: <T = any>(id: string, url: string) => Promise<T>;
2764     add: (id: string, data: any) => void;
2765 }
2766 declare type WithSubItems<T, K extends keyof T> = T[K] extends Array<any> ? (T & T[K][number]) : T;
2767 interface Props<A extends any[] = any[]> {
2768     Mixins?: Array<Record<string, any>>;
2769     Methods?: string;
2770     Properties?: string;
2771     Statics?: Record<string, any>;
2772     Defaults?: Record<string, any>;
2773     init?: (...args: A) => void;
2774 }
2775 declare type ExtendedClass<T extends Props<A>, A extends any[]> = WithSubItems<T, 'Mixins'>;
2776 interface ExtendedClassConstructor<T extends Props<A>, A extends any[] = any[]> extends Class {
2777     readonly prototype: ExtendedClass<T, A>;
2778     new (...args: A): ExtendedClass<T, A>;
2779     [key: string]: T['Statics'];
2780 }
2781 interface Class {
2782     extend<T extends Props<A>, A extends any[] = any[]>(props: T): ExtendedClassConstructor<T, A>;
2783 }
2784 interface RGB {
2785     r: number;
2786     g: number;
2787     b: number;
2788 }
2789 interface HSV {
2790     h: number;
2791     s: number;
2792     v: number;
2793 }
2794 declare type ColorConstructor = new (value?: string | RGB | HSV) => Color;
2795 interface Color {
2796     toRgb: () => RGB;
2797     toHsv: () => HSV;
2798     toHex: () => string;
2799     parse: (value: string | RGB | HSV) => Color;
2800 }
2801 interface DebounceFunc<T extends (...args: any[]) => void> {
2802     (...args: Parameters<T>): void;
2803     stop: () => void;
2804 }
2805 interface Delay {
2806     requestAnimationFrame: (callback: () => void, element?: HTMLElement) => void;
2807     setEditorInterval: (editor: Editor, callback: () => void, time?: number) => number;
2808     setEditorTimeout: (editor: Editor, callback: () => void, time?: number) => number;
2809     setInterval: (callback: () => void, time?: number) => number;
2810     setTimeout: (callback: () => void, time?: number) => number;
2811     clearInterval: (id?: number) => void;
2812     clearTimeout: (id?: number) => void;
2813     debounce: <T extends (...args: any[]) => any>(callback: T, time?: number) => DebounceFunc<T>;
2814     throttle: <T extends (...args: any[]) => any>(callback: T, time?: number) => DebounceFunc<T>;
2815 }
2816 declare type UploadResult = UploadResult$2;
2817 interface ImageUploader {
2818     upload: (blobInfos: BlobInfo[], showNotification?: boolean) => Promise<UploadResult[]>;
2819 }
2820 interface JSONUtils {
2821     serialize: (obj: any) => string;
2822     parse: (text: string) => any;
2823 }
2824 interface JSONPSettings {
2825     count?: number;
2826     url: string;
2827     callback: (json: string) => void;
2828 }
2829 interface JSONP {
2830     callbacks: {};
2831     count: number;
2832     send(this: JSONP, settings: JSONPSettings): void;
2833 }
2834 interface JSONRequestSettings {
2835     crossDomain?: boolean;
2836     requestheaders?: Record<string, {
2837         key: string;
2838         value: string;
2839     }>;
2840     type?: string;
2841     url?: string;
2842     error_scope?: any;
2843     success_scope?: any;
2844     success?: (data: any) => void;
2845     error?: (error: any, xhr: XMLHttpRequest) => void;
2846 }
2847 interface JSONRequestArgs extends JSONRequestSettings {
2848     id?: string;
2849     method?: string;
2850     params?: string;
2851 }
2852 interface JSONRequestConstructor {
2853     readonly prototype: JSONRequest;
2854     new (settings?: JSONRequestSettings): JSONRequest;
2855     sendRPC: (o: JSONRequestArgs) => void;
2856 }
2857 declare class JSONRequest {
2858     static sendRPC(o: JSONRequestArgs): void;
2859     settings: JSONRequestSettings;
2860     count: number;
2861     constructor(settings?: JSONRequestSettings);
2862     send(args: JSONRequestArgs): void;
2863 }
2864 interface KeyboardLikeEvent {
2865     shiftKey: boolean;
2866     ctrlKey: boolean;
2867     altKey: boolean;
2868     metaKey: boolean;
2869 }
2870 interface VK {
2871     BACKSPACE: number;
2872     DELETE: number;
2873     DOWN: number;
2874     ENTER: number;
2875     ESC: number;
2876     LEFT: number;
2877     RIGHT: number;
2878     SPACEBAR: number;
2879     TAB: number;
2880     UP: number;
2881     PAGE_UP: number;
2882     PAGE_DOWN: number;
2883     END: number;
2884     HOME: number;
2885     modifierPressed: (e: KeyboardLikeEvent) => boolean;
2886     metaKeyPressed: (e: KeyboardLikeEvent) => boolean;
2887 }
2888 interface XHRSettings {
2889     async?: boolean;
2890     content_type?: string;
2891     crossDomain?: boolean;
2892     data?: Document | BodyInit;
2893     requestheaders?: Record<string, {
2894         key: string;
2895         value: string;
2896     }>;
2897     scope?: any;
2898     type?: string;
2899     url: string;
2900     error_scope?: any;
2901     success_scope?: any;
2902     error?: (message: 'TIMED_OUT' | 'GENERAL', xhr: XMLHttpRequest, settings: XHRSettings) => void;
2903     success?: (text: string, xhr: XMLHttpRequest, settings: XHRSettings) => void;
2904 }
2905 interface XHREventMap {
2906     beforeInitialize: {
2907         settings: XHRSettings;
2908     };
2909     beforeSend: {
2910         xhr: XMLHttpRequest;
2911         settings: XHRSettings;
2912     };
2913 }
2914 interface XHR extends Observable<XHREventMap> {
2915     send(this: XHR, settings: XHRSettings): void;
2916 }
2917 interface DOMUtilsNamespace {
2918     new (doc: Document, settings: Partial<DOMUtilsSettings>): DOMUtils;
2919     DOM: DOMUtils;
2920     nodeIndex: (node: Node, normalized?: boolean) => number;
2921 }
2922 interface RangeUtilsNamespace {
2923     new (dom: DOMUtils): RangeUtils;
2924     compareRanges: (rng1: RangeLikeObject, rng2: RangeLikeObject) => boolean;
2925     getCaretRangeFromPoint: (clientX: number, clientY: number, doc: Document) => Range;
2926     getSelectedNode: (range: Range) => Node;
2927     getNode: (container: Node, offset: number) => Node;
2928 }
2929 interface AddOnManagerNamespace {
2930     new <T>(): AddOnManager<T>;
2931     language: string | undefined;
2932     languageLoad: boolean;
2933     baseURL: string;
2934     PluginManager: PluginManager;
2935     ThemeManager: ThemeManager;
2936 }
2937 interface BookmarkManagerNamespace {
2938     (selection: EditorSelection): BookmarkManager;
2939     isBookmarkNode: (node: Node) => boolean;
2940 }
2941 interface SaxParserNamespace {
2942     new (settings?: SaxParserSettings, schema?: Schema): SaxParser;
2943     findEndTag: (schema: Schema, html: string, startIndex: number) => number;
2944 }
2945 interface TinyMCE extends EditorManager {
2946     geom: {
2947         Rect: Rect;
2948     };
2949     util: {
2950         Promise: PromiseConstructor;
2951         Delay: Delay;
2952         Tools: Tools;
2953         VK: VK;
2954         URI: URIConstructor;
2955         Class: Class;
2956         EventDispatcher: EventDispatcherConstructor<any>;
2957         Observable: Observable<any>;
2958         I18n: I18n;
2959         XHR: XHR;
2960         JSON: JSONUtils;
2961         JSONRequest: JSONRequestConstructor;
2962         JSONP: JSONP;
2963         LocalStorage: Storage;
2964         Color: ColorConstructor;
2965         ImageUploader: ImageUploader;
2966     };
2967     dom: {
2968         EventUtils: EventUtilsConstructor;
2969         Sizzle: any;
2970         DomQuery: DomQueryConstructor;
2971         TreeWalker: DomTreeWalkerConstructor;
2972         TextSeeker: new (dom: DOMUtils, isBlockBoundary?: (node: Node) => boolean) => TextSeeker;
2973         DOMUtils: DOMUtilsNamespace;
2974         ScriptLoader: ScriptLoaderConstructor;
2975         RangeUtils: RangeUtilsNamespace;
2976         Serializer: new (settings: DomSerializerSettings, editor?: Editor) => DomSerializer;
2977         ControlSelection: (selection: EditorSelection, editor: Editor) => ControlSelection;
2978         BookmarkManager: BookmarkManagerNamespace;
2979         Selection: new (dom: DOMUtils, win: Window, serializer: DomSerializer, editor: Editor) => EditorSelection;
2980         StyleSheetLoader: new (documentOrShadowRoot: Document | ShadowRoot, settings: StyleSheetLoaderSettings) => StyleSheetLoader;
2981         Event: EventUtils;
2982     };
2983     html: {
2984         Styles: new (settings?: StylesSettings, schema?: Schema) => Styles;
2985         Entities: Entities;
2986         Node: AstNodeConstructor;
2987         Schema: new (settings?: SchemaSettings) => Schema;
2988         SaxParser: SaxParserNamespace;
2989         DomParser: new (settings?: DomParserSettings, schema?: Schema) => DomParser;
2990         Writer: new (settings?: WriterSettings) => Writer;
2991         Serializer: new (settings?: HtmlSerializerSettings, schema?: Schema) => HtmlSerializer;
2992     };
2993     AddOnManager: AddOnManagerNamespace;
2994     Annotator: new (editor: Editor) => Annotator;
2995     Editor: EditorConstructor;
2996     EditorCommands: EditorCommandsConstructor;
2997     EditorManager: EditorManager;
2998     EditorObservable: EditorObservable;
2999     Env: Env;
3000     FocusManager: FocusManager;
3001     Formatter: new (editor: Editor) => Formatter;
3002     NotificationManager: new (editor: Editor) => NotificationManager;
3003     Shortcuts: ShortcutsConstructor;
3004     UndoManager: new (editor: Editor) => UndoManager;
3005     WindowManager: new (editor: Editor) => WindowManager;
3006     DOM: DOMUtils;
3007     ScriptLoader: ScriptLoader;
3008     PluginManager: PluginManager;
3009     ThemeManager: ThemeManager;
3010     IconManager: IconManager;
3011     Resource: Resource;
3012     trim: Tools['trim'];
3013     isArray: Tools['isArray'];
3014     is: Tools['is'];
3015     toArray: Tools['toArray'];
3016     makeMap: Tools['makeMap'];
3017     each: Tools['each'];
3018     map: Tools['map'];
3019     grep: Tools['grep'];
3020     inArray: Tools['inArray'];
3021     extend: Tools['extend'];
3022     create: Tools['create'];
3023     walk: Tools['walk'];
3024     createNS: Tools['createNS'];
3025     resolve: Tools['resolve'];
3026     explode: Tools['explode'];
3027     _addCacheSuffix: Tools['_addCacheSuffix'];
3028     isOpera: boolean;
3029     isWebKit: boolean;
3030     isIE: false | number;
3031     isGecko: boolean;
3032     isMac: boolean;
3033 }
3034 declare const tinymce: TinyMCE;
3035 export default tinymce;
3036 export { AddOnManager, Annotator, AstNode, Bookmark, BookmarkManager, Class, Color, ControlSelection, DOMUtils, Delay, DomParser, DomParserSettings, DomQuery, DomSerializer, DomSerializerSettings, DomTreeWalker, Editor, EditorCommands, EditorEvent, EditorManager, EditorModeApi, EditorObservable, EditorSelection, EditorSettings, Entities, Env, EventDispatcher, EventUtils, EventTypes_d as Events, FocusManager, Format_d as Formats, Formatter, GeomRect, HtmlSerializer, HtmlSerializerSettings, I18n, IconManager, JSONUtils as JSON, JSONP, JSONRequest, JSONRequestArgs, JSONRequestSettings, NotificationApi, NotificationManager, NotificationSpec, Observable, Plugin, PluginManager, RangeUtils, RawEditorSettings, Rect, Resource, SaxParser, SaxParserSettings, Schema, SchemaSettings, ScriptLoader, Shortcuts, StyleSheetLoader, Styles, TextSeeker, Theme, ThemeManager, TinyMCE, Tools, URI, Ui_d as Ui, UndoManager, VK, WindowManager, Writer, WriterSettings, XHR, XHRSettings };