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

1 interface StringPathBookmark {

2 start: string;

3 end?: string;

4 forward?: boolean;

5 }

6 interface RangeBookmark {

7 rng: Range;

8 forward?: boolean;

9 }

10 interface IdBookmark {

11 id: string;

12 keep?: boolean;

13 forward?: boolean;

14 }

15 interface IndexBookmark {

16 name: string;

17 index: number;

18 }

19 interface PathBookmark {

20 start: number[];

21 end?: number[];

22 isFakeCaret?: boolean;

23 forward?: boolean;

24 }

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

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

27 readonly type: string;

28 readonly target: T;

29 readonly isDefaultPrevented: () => boolean;

30 readonly preventDefault: () => void;

31 readonly isPropagationStopped: () => boolean;

32 readonly stopPropagation: () => void;

33 readonly isImmediatePropagationStopped: () => boolean;

34 readonly stopImmediatePropagation: () => void;

35 };

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

37 interface NativeEventMap {

38 'beforepaste': Event;

39 'blur': FocusEvent;

40 'beforeinput': InputEvent;

41 'click': MouseEvent;

42 'compositionend': Event;

43 'compositionstart': Event;

44 'compositionupdate': Event;

45 'contextmenu': PointerEvent;

46 'copy': ClipboardEvent;

47 'cut': ClipboardEvent;

48 'dblclick': MouseEvent;

49 'drag': DragEvent;

50 'dragdrop': DragEvent;

51 'dragend': DragEvent;

52 'draggesture': DragEvent;

53 'dragover': DragEvent;

54 'dragstart': DragEvent;

55 'drop': DragEvent;

56 'focus': FocusEvent;

57 'focusin': FocusEvent;

58 'focusout': FocusEvent;

59 'input': InputEvent;

60 'keydown': KeyboardEvent;

61 'keypress': KeyboardEvent;

62 'keyup': KeyboardEvent;

63 'mousedown': MouseEvent;

64 'mouseenter': MouseEvent;

65 'mouseleave': MouseEvent;

66 'mousemove': MouseEvent;

67 'mouseout': MouseEvent;

68 'mouseover': MouseEvent;

69 'mouseup': MouseEvent;

70 'paste': ClipboardEvent;

71 'selectionchange': Event;

72 'submit': Event;

73 'touchend': TouchEvent;

74 'touchmove': TouchEvent;

75 'touchstart': TouchEvent;

76 'touchcancel': TouchEvent;

77 'wheel': WheelEvent;

78 }

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

80 interface EventDispatcherSettings {

81 scope?: any;

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

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

84 }

85 interface EventDispatcherConstructor<T extends NativeEventMap> {

86 readonly prototype: EventDispatcher<T>;

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

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

89 }

90 declare class EventDispatcher<T> {

91 static isNative(name: string): boolean;

92 private readonly settings;

93 private readonly scope;

94 private readonly toggleEvent;

95 private bindings;

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

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

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

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

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

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

102 has(name: string): boolean;

103 }

104 declare const enum UndoLevelType {

105 Fragmented = "fragmented",

106 Complete = "complete"

107 }

108 interface UndoLevel {

109 type: UndoLevelType;

110 fragments: string[];

111 content: string;

112 bookmark: Bookmark;

113 beforeBookmark: Bookmark;

114 }

115 interface UndoManager {

116 data: UndoLevel[];

117 typing: boolean;

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

119 dispatchChange: () => void;

120 beforeChange: () => void;

121 undo: () => UndoLevel;

122 redo: () => UndoLevel;

123 clear: () => void;

124 reset: () => void;

125 hasUndo: () => boolean;

126 hasRedo: () => boolean;

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

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

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

130 }

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

132 interface SchemaSettings {

133 custom_elements?: string;

134 extended_valid_elements?: string;

135 invalid_elements?: string;

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

137 schema?: SchemaType;

138 valid_children?: string;

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

140 valid_elements?: string;

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

142 verify_html?: boolean;

143 padd_empty_block_inline_children?: boolean;

144 }

145 interface Attribute {

146 required?: boolean;

147 defaultValue?: string;

148 forcedValue?: string;

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

150 }

151 interface DefaultAttribute {

152 name: string;

153 value: string;

154 }

155 interface AttributePattern {

156 defaultValue?: string;

157 forcedValue?: string;

158 pattern: RegExp;

159 required?: boolean;

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

161 }

162 interface ElementRule {

163 attributes: Record<string, Attribute>;

164 attributesDefault?: DefaultAttribute[];

165 attributesForced?: DefaultAttribute[];

166 attributesOrder: string[];

167 attributePatterns?: AttributePattern[];

168 attributesRequired?: string[];

169 paddEmpty?: boolean;

170 removeEmpty?: boolean;

171 removeEmptyAttrs?: boolean;

172 paddInEmptyBlock?: boolean;

173 }

174 interface SchemaElement extends ElementRule {

175 outputName?: string;

176 parentsRequired?: string[];

177 pattern?: RegExp;

178 }

179 interface SchemaMap {

180 [name: string]: {};

181 }

182 interface SchemaRegExpMap {

183 [name: string]: RegExp;

184 }

185 interface Schema {

186 type: SchemaType;

187 children: Record<string, SchemaMap>;

188 elements: Record<string, SchemaElement>;

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

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

191 getBlockElements: () => SchemaMap;

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

193 getVoidElements: () => SchemaMap;

194 getTextBlockElements: () => SchemaMap;

195 getTextInlineElements: () => SchemaMap;

196 getBoolAttrs: () => SchemaMap;

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

198 getSelfClosingElements: () => SchemaMap;

199 getNonEmptyElements: () => SchemaMap;

200 getMoveCaretBeforeOnEnterElements: () => SchemaMap;

201 getWhitespaceElements: () => SchemaMap;

202 getSpecialElements: () => SchemaRegExpMap;

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

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

205 getCustomElements: () => SchemaMap;

206 addValidElements: (validElements: string) => void;

207 setValidElements: (validElements: string) => void;

208 addCustomElements: (customElements: string) => void;

209 addValidChildren: (validChildren: any) => void;

210 }

211 declare type Attributes$1 = Array<{

212 name: string;

213 value: string;

214 }> & {

215 map: Record<string, string>;

216 };

217 interface AstNodeConstructor {

218 readonly prototype: AstNode;

219 new (name: string, type: number): AstNode;

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

221 }

222 declare class AstNode {

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

224 name: string;

225 type: number;

226 attributes?: Attributes$1;

227 value?: string;

228 parent?: AstNode;

229 firstChild?: AstNode;

230 lastChild?: AstNode;

231 next?: AstNode;

232 prev?: AstNode;

233 raw?: boolean;

234 constructor(name: string, type: number);

235 replace(node: AstNode): AstNode;

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

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

238 attr(name: string): string | undefined;

239 clone(): AstNode;

240 wrap(wrapper: AstNode): AstNode;

241 unwrap(): void;

242 remove(): AstNode;

243 append(node: AstNode): AstNode;

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

245 getAll(name: string): AstNode[];

246 children(): AstNode[];

247 empty(): AstNode;

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

249 walk(prev?: boolean): AstNode;

250 }

251 declare type Content = string | AstNode;

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

253 interface GetContentArgs {

254 format: ContentFormat;

255 get: boolean;

256 getInner: boolean;

257 no_events?: boolean;

258 save?: boolean;

259 source_view?: boolean;

260 [key: string]: any;

261 }

262 interface SetContentArgs {

263 format: string;

264 set: boolean;

265 content: Content;

266 no_events?: boolean;

267 no_selection?: boolean;

268 paste?: boolean;

269 }

270 interface GetSelectionContentArgs extends GetContentArgs {

271 selection?: boolean;

272 contextual?: boolean;

273 }

274 interface SetSelectionContentArgs extends SetContentArgs {

275 content: string;

276 selection?: boolean;

277 }

278 interface BlobInfoData {

279 id?: string;

280 name?: string;

281 filename?: string;

282 blob: Blob;

283 base64: string;

284 blobUri?: string;

285 uri?: string;

286 }

287 interface BlobInfo {

288 id: () => string;

289 name: () => string;

290 filename: () => string;

291 blob: () => Blob;

292 base64: () => string;

293 blobUri: () => string;

294 uri: () => string | undefined;

295 }

296 interface BlobCache {

297 create: {

298 (o: BlobInfoData): BlobInfo;

299 (id: string, blob: Blob, base64: string, name?: string, filename?: string): BlobInfo;

300 };

301 add: (blobInfo: BlobInfo) => void;

302 get: (id: string) => BlobInfo | undefined;

303 getByUri: (blobUri: string) => BlobInfo | undefined;

304 getByData: (base64: string, type: string) => BlobInfo | undefined;

305 findFirst: (predicate: (blobInfo: BlobInfo) => boolean) => BlobInfo | undefined;

306 removeByUri: (blobUri: string) => void;

307 destroy: () => void;

308 }

309 interface BlobInfoImagePair {

310 image: HTMLImageElement;

311 blobInfo: BlobInfo;

312 }

313 declare class NodeChange {

314 private readonly editor;

315 private lastPath;

316 constructor(editor: Editor);

317 nodeChanged(args?: any): void;

318 private isSameElementPath;

319 }

320 interface SelectionOverrides {

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

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

323 hideFakeCaret: () => void;

324 destroy: () => void;

325 }

326 interface Quirks {

327 refreshContentEditable(): void;

328 isHidden(): boolean;

329 }

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

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

332 attributes?: {};

333 classes?: string[];

334 };

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

336 uid: string;

337 nodes: any[];

338 }) => void;

339 declare type AnnotationListenerApi = AnnotationListener;

340 interface AnnotatorSettings {

341 decorate: Decorator;

342 persistent?: boolean;

343 }

344 interface Annotator {

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

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

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

348 remove: (name: string) => void;

349 removeAll: (name: string) => void;

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

351 }

352 interface GeomRect {

353 readonly x: number;

354 readonly y: number;

355 readonly w: number;

356 readonly h: number;

357 }

358 interface Rect {

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

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

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

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

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

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

365 fromClientRect: (clientRect: DOMRect) => GeomRect;

366 }

367 interface NotificationManagerImpl {

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

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

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

371 }

372 interface NotificationSpec {

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

374 text: string;

375 icon?: string;

376 progressBar?: boolean;

377 timeout?: number;

378 closeButton?: boolean;

379 }

380 interface NotificationApi {

381 close: () => void;

382 progressBar: {

383 value: (percent: number) => void;

384 };

385 text: (text: string) => void;

386 reposition: () => void;

387 getEl: () => HTMLElement;

388 settings: NotificationSpec;

389 }

390 interface NotificationManager {

391 open: (spec: NotificationSpec) => NotificationApi;

392 close: () => void;

393 getNotifications: () => NotificationApi[];

394 }

395 interface UploadFailure {

396 message: string;

397 remove?: boolean;

398 }

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

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

401 interface UploadResult$2 {

402 url: string;

403 blobInfo: BlobInfo;

404 status: boolean;

405 error?: UploadFailure;

406 }

407 interface RawPattern {

408 start?: any;

409 end?: any;

410 format?: any;

411 cmd?: any;

412 value?: any;

413 replacement?: any;

414 }

415 interface InlineBasePattern {

416 readonly start: string;

417 readonly end: string;

418 }

419 interface InlineFormatPattern extends InlineBasePattern {

420 readonly type: 'inline-format';

421 readonly format: string[];

422 }

423 interface InlineCmdPattern extends InlineBasePattern {

424 readonly type: 'inline-command';

425 readonly cmd: string;

426 readonly value?: any;

427 }

428 declare type InlinePattern = InlineFormatPattern | InlineCmdPattern;

429 interface BlockBasePattern {

430 readonly start: string;

431 }

432 interface BlockFormatPattern extends BlockBasePattern {

433 readonly type: 'block-format';

434 readonly format: string;

435 }

436 interface BlockCmdPattern extends BlockBasePattern {

437 readonly type: 'block-command';

438 readonly cmd: string;

439 readonly value?: any;

440 }

441 declare type BlockPattern = BlockFormatPattern | BlockCmdPattern;

442 declare type Pattern = InlinePattern | BlockPattern;

443 interface AlertBannerSpec {

444 type: 'alertbanner';

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

446 text: string;

447 icon: string;

448 url?: string;

449 }

450 interface ButtonSpec {

451 type: 'button';

452 text: string;

453 enabled?: boolean;

454 primary?: boolean;

455 name?: string;

456 icon?: string;

457 borderless?: boolean;

458 buttonType?: 'primary' | 'secondary' | 'toolbar';

459 }

460 interface FormComponentSpec {

461 type: string;

462 name: string;

463 }

464 interface FormComponentWithLabelSpec extends FormComponentSpec {

465 label?: string;

466 }

467 interface CheckboxSpec extends FormComponentSpec {

468 type: 'checkbox';

469 label: string;

470 enabled?: boolean;

471 }

472 interface CollectionSpec extends FormComponentWithLabelSpec {

473 type: 'collection';

474 }

475 interface CollectionItem {

476 value: string;

477 text: string;

478 icon: string;

479 }

480 interface ColorInputSpec extends FormComponentWithLabelSpec {

481 type: 'colorinput';

482 }

483 interface ColorPickerSpec extends FormComponentWithLabelSpec {

484 type: 'colorpicker';

485 }

486 interface CustomEditorInit {

487 setValue: (value: string) => void;

488 getValue: () => string;

489 destroy: () => void;

490 }

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

492 interface CustomEditorOldSpec extends FormComponentSpec {

493 type: 'customeditor';

494 tag?: string;

495 init: (e: HTMLElement) => Promise<CustomEditorInit>;

496 }

497 interface CustomEditorNewSpec extends FormComponentSpec {

498 type: 'customeditor';

499 tag?: string;

500 scriptId: string;

501 scriptUrl: string;

502 settings?: any;

503 }

504 declare type CustomEditorSpec = CustomEditorOldSpec | CustomEditorNewSpec;

505 interface DropZoneSpec extends FormComponentWithLabelSpec {

506 type: 'dropzone';

507 }

508 interface GridSpec {

509 type: 'grid';

510 columns: number;

511 items: BodyComponentSpec[];

512 }

513 interface HtmlPanelSpec {

514 type: 'htmlpanel';

515 html: string;

516 presets?: 'presentation' | 'document';

517 }

518 interface IframeSpec extends FormComponentWithLabelSpec {

519 type: 'iframe';

520 sandboxed?: boolean;

521 transparent?: boolean;

522 }

523 interface ImagePreviewSpec extends FormComponentSpec {

524 type: 'imagepreview';

525 height?: string;

526 }

527 interface InputSpec extends FormComponentWithLabelSpec {

528 type: 'input';

529 inputMode?: string;

530 placeholder?: string;

531 maximized?: boolean;

532 enabled?: boolean;

533 }

534 interface LabelSpec {

535 type: 'label';

536 label: string;

537 items: BodyComponentSpec[];

538 }

539 interface ListBoxSingleItemSpec {

540 text: string;

541 value: string;

542 }

543 interface ListBoxNestedItemSpec {

544 text: string;

545 items: ListBoxItemSpec[];

546 }

547 declare type ListBoxItemSpec = ListBoxNestedItemSpec | ListBoxSingleItemSpec;

548 interface ListBoxSpec extends FormComponentWithLabelSpec {

549 type: 'listbox';

550 items: ListBoxItemSpec[];

551 disabled?: boolean;

552 }

553 interface PanelSpec {

554 type: 'panel';

555 classes?: string[];

556 items: BodyComponentSpec[];

557 }

558 interface SelectBoxItemSpec {

559 text: string;

560 value: string;

561 }

562 interface SelectBoxSpec extends FormComponentWithLabelSpec {

563 type: 'selectbox';

564 items: SelectBoxItemSpec[];

565 size?: number;

566 enabled?: boolean;

567 }

568 interface SizeInputSpec extends FormComponentWithLabelSpec {

569 type: 'sizeinput';

570 constrain?: boolean;

571 enabled?: boolean;

572 }

573 interface SliderSpec extends FormComponentSpec {

574 type: 'slider';

575 label: string;

576 min?: number;

577 max?: number;

578 }

579 interface TableSpec {

580 type: 'table';

581 header: string[];

582 cells: string[][];

583 }

584 interface TextAreaSpec extends FormComponentWithLabelSpec {

585 type: 'textarea';

586 placeholder?: string;

587 maximized?: boolean;

588 enabled?: boolean;

589 }

590 interface UrlInputSpec extends FormComponentWithLabelSpec {

591 type: 'urlinput';

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

593 enabled?: boolean;

594 }

595 interface UrlInputData {

596 value: string;

597 meta: {

598 text?: string;

599 };

600 }

602 interface BarSpec {

603 type: 'bar';

604 items: BodyComponentSpec[];

605 }

606 interface CommonMenuItemSpec {

607 enabled?: boolean;

608 text?: string;

609 value?: string;

610 meta?: Record<string, any>;

611 shortcut?: string;

612 }

613 interface CommonMenuItemInstanceApi {

614 isEnabled: () => boolean;

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

616 }

617 interface DialogToggleMenuItemSpec extends CommonMenuItemSpec {

618 type?: 'togglemenuitem';

619 name: string;

620 }

621 declare type DialogFooterMenuButtonItemSpec = DialogToggleMenuItemSpec;

622 interface BaseDialogFooterButtonSpec {

623 name?: string;

624 align?: 'start' | 'end';

625 primary?: boolean;

626 enabled?: boolean;

627 icon?: string;

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

629 }

630 interface DialogFooterNormalButtonSpec extends BaseDialogFooterButtonSpec {

631 type: 'submit' | 'cancel' | 'custom';

632 text: string;

633 }

634 interface DialogFooterMenuButtonSpec extends BaseDialogFooterButtonSpec {

635 type: 'menu';

636 text?: string;

637 tooltip?: string;

638 icon?: string;

639 items: DialogFooterMenuButtonItemSpec[];

640 }

641 declare type DialogFooterButtonSpec = DialogFooterNormalButtonSpec | DialogFooterMenuButtonSpec;

642 interface TabSpec {

643 name?: string;

644 title: string;

645 items: BodyComponentSpec[];

646 }

647 interface TabPanelSpec {

648 type: 'tabpanel';

649 tabs: TabSpec[];

650 }

651 declare type DialogDataItem = any;

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

653 interface DialogInstanceApi<T extends DialogData> {

654 getData: () => T;

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

656 setEnabled: (name: string, state: boolean) => void;

657 focus: (name: string) => void;

658 showTab: (name: string) => void;

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

660 block: (msg: string) => void;

661 unblock: () => void;

662 close: () => void;

663 }

664 interface DialogActionDetails {

665 name: string;

666 value?: any;

667 }

668 interface DialogChangeDetails<T> {

669 name: keyof T;

670 }

671 interface DialogTabChangeDetails {

672 newTabName: string;

673 oldTabName: string;

674 }

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

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

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

678 declare type DialogCloseHandler = () => void;

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

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

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

682 interface DialogSpec<T extends DialogData> {

683 title: string;

684 size?: DialogSize;

685 body: TabPanelSpec | PanelSpec;

686 buttons: DialogFooterButtonSpec[];

687 initialData?: Partial<T>;

688 onAction?: DialogActionHandler<T>;

689 onChange?: DialogChangeHandler<T>;

690 onSubmit?: DialogSubmitHandler<T>;

691 onClose?: DialogCloseHandler;

692 onCancel?: DialogCancelHandler<T>;

693 onTabChange?: DialogTabChangeHandler<T>;

694 }

695 interface UrlDialogInstanceApi {

696 block: (msg: string) => void;

697 unblock: () => void;

698 close: () => void;

699 sendMessage: (msg: any) => void;

700 }

701 interface UrlDialogActionDetails {

702 name: string;

703 value?: any;

704 }

705 interface UrlDialogMessage {

706 mceAction: string;

707 [key: string]: any;

708 }

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

710 declare type UrlDialogCloseHandler = () => void;

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

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

713 interface UrlDialogFooterButtonSpec extends DialogFooterNormalButtonSpec {

714 type: 'cancel' | 'custom';

715 }

716 interface UrlDialogSpec {

717 title: string;

718 url: string;

719 height?: number;

720 width?: number;

721 buttons?: UrlDialogFooterButtonSpec[];

722 onAction?: UrlDialogActionHandler;

723 onClose?: UrlDialogCloseHandler;

724 onCancel?: UrlDialogCancelHandler;

725 onMessage?: UrlDialogMessageHandler;

726 }

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

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

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

730 interface CardContainerSpec {

731 type: 'cardcontainer';

732 items: CardItemSpec[];

733 direction?: CardContainerDirection;

734 align?: CardContainerAlign;

735 valign?: CardContainerValign;

736 }

737 interface CardImageSpec {

738 type: 'cardimage';

739 src: string;

740 alt?: string;

741 classes?: string[];

742 }

743 interface CardTextSpec {

744 type: 'cardtext';

745 text: string;

746 name?: string;

747 classes?: string[];

748 }

749 declare type CardItemSpec = CardContainerSpec | CardImageSpec | CardTextSpec;

750 interface CardMenuItemInstanceApi extends CommonMenuItemInstanceApi {

751 }

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

753 type: 'cardmenuitem';

754 label?: string;

755 items: CardItemSpec[];

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

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

758 }

759 interface SeparatorMenuItemSpec {

760 type?: 'separator';

761 text?: string;

762 }

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

764 declare type SeparatorItemSpec = SeparatorMenuItemSpec;

765 interface AutocompleterItemSpec {

766 type?: 'autocompleteitem';

767 value: string;

768 text?: string;

769 icon?: string;

770 meta?: Record<string, any>;

771 }

772 declare type AutocompleterContents = SeparatorItemSpec | AutocompleterItemSpec | CardMenuItemSpec;

773 interface AutocompleterSpec {

774 type?: 'autocompleter';

775 ch: string;

776 minChars?: number;

777 columns?: ColumnTypes$1;

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

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

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

781 maxResults?: number;

782 highlightOn?: string[];

783 }

784 interface AutocompleterInstanceApi {

785 hide: () => void;

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

787 }

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

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

790 interface ContextBarSpec {

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

792 position?: ContextPosition;

793 scope?: ContextScope;

794 }

795 interface BaseToolbarButtonSpec {

796 enabled?: boolean;

797 tooltip?: string;

798 icon?: string;

799 text?: string;

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

801 }

802 interface BaseToolbarButtonInstanceApi {

803 isEnabled: () => boolean;

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

805 }

806 interface ToolbarButtonSpec extends BaseToolbarButtonSpec<ToolbarButtonInstanceApi> {

807 type?: 'button';

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

809 }

810 interface ToolbarButtonInstanceApi extends BaseToolbarButtonInstanceApi {

811 }

812 interface BaseToolbarToggleButtonSpec extends BaseToolbarButtonSpec {

813 active?: boolean;

814 }

815 interface BaseToolbarToggleButtonInstanceApi extends BaseToolbarButtonInstanceApi {

816 isActive: () => boolean;

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

818 }

819 interface ToolbarToggleButtonSpec extends BaseToolbarToggleButtonSpec<ToolbarToggleButtonInstanceApi> {

820 type?: 'togglebutton';

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

822 }

823 interface ToolbarToggleButtonInstanceApi extends BaseToolbarToggleButtonInstanceApi {

824 }

825 interface ContextFormLaunchButtonApi extends BaseToolbarButtonSpec<BaseToolbarButtonInstanceApi> {

826 type: 'contextformbutton';

827 }

828 interface ContextFormLaunchToggleButtonSpec extends BaseToolbarToggleButtonSpec<BaseToolbarToggleButtonInstanceApi> {

829 type: 'contextformtogglebutton';

830 }

831 interface ContextFormButtonInstanceApi extends BaseToolbarButtonInstanceApi {

832 }

833 interface ContextFormToggleButtonInstanceApi extends BaseToolbarToggleButtonInstanceApi {

834 }

835 interface ContextFormButtonSpec extends BaseToolbarButtonSpec<ContextFormButtonInstanceApi> {

836 type?: 'contextformbutton';

837 primary?: boolean;

838 onAction: (formApi: ContextFormInstanceApi, api: ContextFormButtonInstanceApi) => void;

839 }

840 interface ContextFormToggleButtonSpec extends BaseToolbarToggleButtonSpec<ContextFormToggleButtonInstanceApi> {

841 type?: 'contextformtogglebutton';

842 onAction: (formApi: ContextFormInstanceApi, buttonApi: ContextFormToggleButtonInstanceApi) => void;

843 primary?: boolean;

844 }

845 interface ContextFormInstanceApi {

846 hide: () => void;

847 getValue: () => string;

848 }

849 interface ContextFormSpec extends ContextBarSpec {

850 type?: 'contextform';

851 initValue?: () => string;

852 label?: string;

853 launch?: ContextFormLaunchButtonApi | ContextFormLaunchToggleButtonSpec;

854 commands: Array<ContextFormToggleButtonSpec | ContextFormButtonSpec>;

855 }

856 interface ContextToolbarSpec extends ContextBarSpec {

857 type?: 'contexttoolbar';

858 items: string;

859 }

860 interface ChoiceMenuItemSpec extends CommonMenuItemSpec {

861 type?: 'choiceitem';

862 icon?: string;

863 }

864 interface ChoiceMenuItemInstanceApi extends CommonMenuItemInstanceApi {

865 isActive: () => boolean;

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

867 }

868 interface ContextMenuItem extends CommonMenuItemSpec {

869 text: string;

870 icon?: string;

871 type?: 'item';

872 onAction: () => void;

873 }

874 interface ContextSubMenu extends CommonMenuItemSpec {

875 type: 'submenu';

876 text: string;

877 icon?: string;

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

879 }

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

881 interface ContextMenuApi {

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

883 }

884 interface FancyActionArgsMap {

885 'inserttable': {

886 numRows: number;

887 numColumns: number;

888 };

889 'colorswatch': {

890 value: string;

891 };

892 }

893 interface BaseFancyMenuItemSpec<T extends keyof FancyActionArgsMap> {

894 type: 'fancymenuitem';

895 fancytype: T;

896 initData?: Record<string, unknown>;

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

898 }

899 interface InsertTableMenuItemSpec extends BaseFancyMenuItemSpec<'inserttable'> {

900 fancytype: 'inserttable';

901 initData?: {};

902 }

903 interface ColorSwatchMenuItemSpec extends BaseFancyMenuItemSpec<'colorswatch'> {

904 fancytype: 'colorswatch';

905 initData?: {

906 allowCustomColors?: boolean;

907 colors: ChoiceMenuItemSpec[];

908 };

909 }

910 declare type FancyMenuItemSpec = InsertTableMenuItemSpec | ColorSwatchMenuItemSpec;

911 interface MenuItemSpec extends CommonMenuItemSpec {

912 type?: 'menuitem';

913 icon?: string;

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

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

916 }

917 interface MenuItemInstanceApi extends CommonMenuItemInstanceApi {

918 }

920 interface NestedMenuItemSpec extends CommonMenuItemSpec {

921 type?: 'nestedmenuitem';

922 icon?: string;

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

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

925 }

926 interface NestedMenuItemInstanceApi extends CommonMenuItemInstanceApi {

927 }

928 interface ToggleMenuItemSpec extends CommonMenuItemSpec {

929 type?: 'togglemenuitem';

930 icon?: string;

931 active?: boolean;

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

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

934 }

935 interface ToggleMenuItemInstanceApi extends CommonMenuItemInstanceApi {

936 isActive: () => boolean;

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

938 }

939 type PublicDialog_d_AlertBannerSpec = AlertBannerSpec;

940 type PublicDialog_d_BarSpec = BarSpec;

941 type PublicDialog_d_BodyComponentSpec = BodyComponentSpec;

942 type PublicDialog_d_ButtonSpec = ButtonSpec;

943 type PublicDialog_d_CheckboxSpec = CheckboxSpec;

944 type PublicDialog_d_CollectionItem = CollectionItem;

945 type PublicDialog_d_CollectionSpec = CollectionSpec;

946 type PublicDialog_d_ColorInputSpec = ColorInputSpec;

947 type PublicDialog_d_ColorPickerSpec = ColorPickerSpec;

948 type PublicDialog_d_CustomEditorSpec = CustomEditorSpec;

949 type PublicDialog_d_CustomEditorInit = CustomEditorInit;

950 type PublicDialog_d_CustomEditorInitFn = CustomEditorInitFn;

951 type PublicDialog_d_DialogData = DialogData;

952 type PublicDialog_d_DialogSize = DialogSize;

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

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

955 type PublicDialog_d_DialogFooterButtonSpec = DialogFooterButtonSpec;

956 type PublicDialog_d_DialogActionDetails = DialogActionDetails;

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

958 type PublicDialog_d_DialogTabChangeDetails = DialogTabChangeDetails;

959 type PublicDialog_d_DropZoneSpec = DropZoneSpec;

960 type PublicDialog_d_GridSpec = GridSpec;

961 type PublicDialog_d_HtmlPanelSpec = HtmlPanelSpec;

962 type PublicDialog_d_IframeSpec = IframeSpec;

963 type PublicDialog_d_ImagePreviewSpec = ImagePreviewSpec;

964 type PublicDialog_d_InputSpec = InputSpec;

965 type PublicDialog_d_LabelSpec = LabelSpec;

966 type PublicDialog_d_ListBoxSpec = ListBoxSpec;

967 type PublicDialog_d_ListBoxItemSpec = ListBoxItemSpec;

968 type PublicDialog_d_ListBoxNestedItemSpec = ListBoxNestedItemSpec;

969 type PublicDialog_d_ListBoxSingleItemSpec = ListBoxSingleItemSpec;

970 type PublicDialog_d_PanelSpec = PanelSpec;

971 type PublicDialog_d_SelectBoxSpec = SelectBoxSpec;

972 type PublicDialog_d_SelectBoxItemSpec = SelectBoxItemSpec;

973 type PublicDialog_d_SizeInputSpec = SizeInputSpec;

974 type PublicDialog_d_SliderSpec = SliderSpec;

975 type PublicDialog_d_TableSpec = TableSpec;

976 type PublicDialog_d_TabSpec = TabSpec;

977 type PublicDialog_d_TabPanelSpec = TabPanelSpec;

978 type PublicDialog_d_TextAreaSpec = TextAreaSpec;

979 type PublicDialog_d_UrlInputData = UrlInputData;

980 type PublicDialog_d_UrlInputSpec = UrlInputSpec;

981 type PublicDialog_d_UrlDialogSpec = UrlDialogSpec;

982 type PublicDialog_d_UrlDialogFooterButtonSpec = UrlDialogFooterButtonSpec;

983 type PublicDialog_d_UrlDialogInstanceApi = UrlDialogInstanceApi;

984 type PublicDialog_d_UrlDialogActionDetails = UrlDialogActionDetails;

985 type PublicDialog_d_UrlDialogMessage = UrlDialogMessage;

986 declare namespace PublicDialog_d {

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

988 }

989 type PublicInlineContent_d_AutocompleterSpec = AutocompleterSpec;

990 type PublicInlineContent_d_AutocompleterItemSpec = AutocompleterItemSpec;

991 type PublicInlineContent_d_AutocompleterContents = AutocompleterContents;

992 type PublicInlineContent_d_AutocompleterInstanceApi = AutocompleterInstanceApi;

993 type PublicInlineContent_d_ContextPosition = ContextPosition;

994 type PublicInlineContent_d_ContextScope = ContextScope;

995 type PublicInlineContent_d_ContextFormSpec = ContextFormSpec;

996 type PublicInlineContent_d_ContextFormInstanceApi = ContextFormInstanceApi;

997 type PublicInlineContent_d_ContextFormButtonSpec = ContextFormButtonSpec;

998 type PublicInlineContent_d_ContextFormButtonInstanceApi = ContextFormButtonInstanceApi;

999 type PublicInlineContent_d_ContextFormToggleButtonSpec = ContextFormToggleButtonSpec;

1000 type PublicInlineContent_d_ContextFormToggleButtonInstanceApi = ContextFormToggleButtonInstanceApi;

1001 type PublicInlineContent_d_ContextToolbarSpec = ContextToolbarSpec;

1002 type PublicInlineContent_d_SeparatorItemSpec = SeparatorItemSpec;

1003 declare namespace PublicInlineContent_d {

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

1005 }

1006 type PublicMenu_d_MenuItemSpec = MenuItemSpec;

1007 type PublicMenu_d_MenuItemInstanceApi = MenuItemInstanceApi;

1008 type PublicMenu_d_NestedMenuItemContents = NestedMenuItemContents;

1009 type PublicMenu_d_NestedMenuItemSpec = NestedMenuItemSpec;

1010 type PublicMenu_d_NestedMenuItemInstanceApi = NestedMenuItemInstanceApi;

1011 type PublicMenu_d_FancyMenuItemSpec = FancyMenuItemSpec;

1012 type PublicMenu_d_ColorSwatchMenuItemSpec = ColorSwatchMenuItemSpec;

1013 type PublicMenu_d_InsertTableMenuItemSpec = InsertTableMenuItemSpec;

1014 type PublicMenu_d_ToggleMenuItemSpec = ToggleMenuItemSpec;

1015 type PublicMenu_d_ToggleMenuItemInstanceApi = ToggleMenuItemInstanceApi;

1016 type PublicMenu_d_ChoiceMenuItemSpec = ChoiceMenuItemSpec;

1017 type PublicMenu_d_ChoiceMenuItemInstanceApi = ChoiceMenuItemInstanceApi;

1018 type PublicMenu_d_SeparatorMenuItemSpec = SeparatorMenuItemSpec;

1019 type PublicMenu_d_ContextMenuApi = ContextMenuApi;

1020 type PublicMenu_d_ContextMenuContents = ContextMenuContents;

1021 type PublicMenu_d_ContextMenuItem = ContextMenuItem;

1022 type PublicMenu_d_ContextSubMenu = ContextSubMenu;

1023 type PublicMenu_d_CardMenuItemSpec = CardMenuItemSpec;

1024 type PublicMenu_d_CardMenuItemInstanceApi = CardMenuItemInstanceApi;

1025 type PublicMenu_d_CardItemSpec = CardItemSpec;

1026 type PublicMenu_d_CardContainerSpec = CardContainerSpec;

1027 type PublicMenu_d_CardImageSpec = CardImageSpec;

1028 type PublicMenu_d_CardTextSpec = CardTextSpec;

1029 declare namespace PublicMenu_d {

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

1031 }

1032 interface SidebarInstanceApi {

1033 element: () => HTMLElement;

1034 }

1035 interface SidebarSpec {

1036 icon?: string;

1037 tooltip?: string;

1038 onShow?: (api: SidebarInstanceApi) => void;

1039 onSetup?: (api: SidebarInstanceApi) => (api: SidebarInstanceApi) => void;

1040 onHide?: (api: SidebarInstanceApi) => void;

1041 }

1042 type PublicSidebar_d_SidebarSpec = SidebarSpec;

1043 type PublicSidebar_d_SidebarInstanceApi = SidebarInstanceApi;

1044 declare namespace PublicSidebar_d {

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

1046 }

1047 interface ToolbarGroupSetting {

1048 name: string;

1049 items: string[];

1050 }

1051 declare type ToolbarConfig = string | ToolbarGroupSetting[];

1052 interface GroupToolbarButtonInstanceApi extends BaseToolbarButtonInstanceApi {

1053 }

1054 interface GroupToolbarButtonSpec extends BaseToolbarButtonSpec<GroupToolbarButtonInstanceApi> {

1055 type?: 'grouptoolbarbutton';

1056 items?: ToolbarConfig;

1057 }

1058 declare type MenuButtonItemTypes = NestedMenuItemContents;

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

1060 interface BaseMenuButtonSpec {

1061 text?: string;

1062 tooltip?: string;

1063 icon?: string;

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

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

1066 }

1067 interface BaseMenuButtonInstanceApi {

1068 isEnabled: () => boolean;

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

1070 isActive: () => boolean;

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

1072 }

1073 interface ToolbarMenuButtonSpec extends BaseMenuButtonSpec {

1074 type?: 'menubutton';

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

1076 }

1077 interface ToolbarMenuButtonInstanceApi extends BaseMenuButtonInstanceApi {

1078 }

1079 declare type ToolbarSplitButtonItemTypes = ChoiceMenuItemSpec | SeparatorMenuItemSpec;

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

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

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

1083 declare type ColumnTypes = number | 'auto';

1084 interface ToolbarSplitButtonSpec {

1085 type?: 'splitbutton';

1086 tooltip?: string;

1087 icon?: string;

1088 text?: string;

1089 select?: SelectPredicate;

1090 presets?: PresetTypes;

1091 columns?: ColumnTypes;

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

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

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

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

1096 }

1097 interface ToolbarSplitButtonInstanceApi {

1098 isEnabled: () => boolean;

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

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

1101 isActive: () => boolean;

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

1103 }

1104 type PublicToolbar_d_ToolbarButtonSpec = ToolbarButtonSpec;

1105 type PublicToolbar_d_ToolbarButtonInstanceApi = ToolbarButtonInstanceApi;

1106 type PublicToolbar_d_ToolbarSplitButtonSpec = ToolbarSplitButtonSpec;

1107 type PublicToolbar_d_ToolbarSplitButtonInstanceApi = ToolbarSplitButtonInstanceApi;

1108 type PublicToolbar_d_ToolbarMenuButtonSpec = ToolbarMenuButtonSpec;

1109 type PublicToolbar_d_ToolbarMenuButtonInstanceApi = ToolbarMenuButtonInstanceApi;

1110 type PublicToolbar_d_ToolbarToggleButtonSpec = ToolbarToggleButtonSpec;

1111 type PublicToolbar_d_ToolbarToggleButtonInstanceApi = ToolbarToggleButtonInstanceApi;

1112 type PublicToolbar_d_GroupToolbarButtonSpec = GroupToolbarButtonSpec;

1113 type PublicToolbar_d_GroupToolbarButtonInstanceApi = GroupToolbarButtonInstanceApi;

1114 declare namespace PublicToolbar_d {

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

1116 }

1117 interface Registry$1 {

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

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

1120 addToggleButton: (name: string, spec: ToolbarToggleButtonSpec) => void;

1121 addMenuButton: (name: string, spec: ToolbarMenuButtonSpec) => void;

1122 addSplitButton: (name: string, spec: ToolbarSplitButtonSpec) => void;

1123 addMenuItem: (name: string, spec: MenuItemSpec) => void;

1124 addNestedMenuItem: (name: string, spec: NestedMenuItemSpec) => void;

1125 addToggleMenuItem: (name: string, spec: ToggleMenuItemSpec) => void;

1126 addContextMenu: (name: string, spec: ContextMenuApi) => void;

1127 addContextToolbar: (name: string, spec: ContextToolbarSpec) => void;

1128 addContextForm: (name: string, spec: ContextFormSpec) => void;

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

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

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

1132 getAll: () => {

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

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

1135 popups: Record<string, AutocompleterSpec>;

1136 contextMenus: Record<string, ContextMenuApi>;

1137 contextToolbars: Record<string, ContextToolbarSpec | ContextFormSpec>;

1138 icons: Record<string, string>;

1139 sidebars: Record<string, SidebarSpec>;

1140 };

1141 }

1142 interface AutocompleteLookupData {

1143 readonly matchText: string;

1144 readonly items: AutocompleterContents[];

1145 readonly columns: ColumnTypes$1;

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

1147 readonly highlightOn: string[];

1148 }

1149 interface AutocompleterEventArgs {

1150 readonly lookupData: AutocompleteLookupData[];

1151 }

1152 interface RangeLikeObject {

1153 startContainer: Node;

1154 startOffset: number;

1155 endContainer: Node;

1156 endOffset: number;

1157 }

1158 declare type ApplyFormat = BlockFormat | InlineFormat | SelectorFormat;

1159 declare type RemoveFormat = RemoveBlockFormat | RemoveInlineFormat | RemoveSelectorFormat;

1160 declare type Format = ApplyFormat | RemoveFormat;

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

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

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

1164 interface BaseFormat<T> {

1165 ceFalseOverride?: boolean;

1166 classes?: string | string[];

1167 collapsed?: boolean;

1168 exact?: boolean;

1169 expand?: boolean;

1170 links?: boolean;

1171 mixed?: boolean;

1172 block_expand?: boolean;

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

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

1175 remove_similar?: boolean;

1176 split?: boolean;

1177 deep?: boolean;

1178 preserve_attributes?: string[];

1179 }

1180 interface Block {

1181 block: string;

1182 list_block?: string;

1183 wrapper?: boolean;

1184 }

1185 interface Inline {

1186 inline: string;

1187 }

1188 interface Selector {

1189 selector: string;

1190 inherit?: boolean;

1191 }

1192 interface CommonFormat<T> extends BaseFormat<T> {

1193 attributes?: Record<string, FormatAttrOrStyleValue>;

1194 styles?: Record<string, FormatAttrOrStyleValue>;

1195 toggle?: boolean;

1196 preview?: string | false;

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

1198 clear_child_styles?: boolean;

1199 merge_siblings?: boolean;

1200 merge_with_parents?: boolean;

1201 }

1202 interface BlockFormat extends Block, CommonFormat<BlockFormat> {

1203 }

1204 interface InlineFormat extends Inline, CommonFormat<InlineFormat> {

1205 }

1206 interface SelectorFormat extends Selector, CommonFormat<SelectorFormat> {

1207 }

1208 interface CommonRemoveFormat<T> extends BaseFormat<T> {

1209 attributes?: string[] | Record<string, FormatAttrOrStyleValue>;

1210 styles?: string[] | Record<string, FormatAttrOrStyleValue>;

1211 }

1212 interface RemoveBlockFormat extends Block, CommonRemoveFormat<RemoveBlockFormat> {

1213 }

1214 interface RemoveInlineFormat extends Inline, CommonRemoveFormat<RemoveInlineFormat> {

1215 }

1216 interface RemoveSelectorFormat extends Selector, CommonRemoveFormat<RemoveSelectorFormat> {

1217 }

1218 interface Filter<C extends Function> {

1219 name: string;

1220 callbacks: C[];

1221 }

1222 interface ParserArgs {

1223 getInner?: boolean | number;

1224 forced_root_block?: boolean | string;

1225 context?: string;

1226 isRootContent?: boolean;

1227 format?: string;

1228 invalid?: boolean;

1229 no_events?: boolean;

1230 [key: string]: any;

1231 }

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

1233 interface ParserFilter extends Filter<ParserFilterCallback> {

1234 }

1235 interface DomParserSettings {

1236 allow_html_data_urls?: boolean;

1237 allow_svg_data_urls?: boolean;

1238 allow_conditional_comments?: boolean;

1239 allow_html_in_named_anchor?: boolean;

1240 allow_script_urls?: boolean;

1241 allow_unsafe_link_target?: boolean;

1242 convert_fonts_to_spans?: boolean;

1243 fix_list_elements?: boolean;

1244 font_size_legacy_values?: string;

1245 forced_root_block?: boolean | string;

1246 forced_root_block_attrs?: Record<string, string>;

1247 preserve_cdata?: boolean;

1248 remove_trailing_brs?: boolean;

1249 root_name?: string;

1250 validate?: boolean;

1251 inline_styles?: boolean;

1252 blob_cache?: BlobCache;

1253 document?: Document;

1254 }

1255 interface DomParser {

1256 schema: Schema;

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

1258 getAttributeFilters: () => ParserFilter[];

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

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

1261 getNodeFilters: () => ParserFilter[];

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

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

1264 }

1265 interface StyleSheetLoaderSettings {

1266 maxLoadTime?: number;

1267 contentCssCors?: boolean;

1268 referrerPolicy?: ReferrerPolicy;

1269 }

1270 interface StyleSheetLoader {

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

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

1273 unload: (url: string) => void;

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

1275 _setReferrerPolicy: (referrerPolicy: ReferrerPolicy) => void;

1276 }

1277 declare type Registry = Registry$1;

1278 interface EditorUiApi {

1279 show: () => void;

1280 hide: () => void;

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

1282 isEnabled: () => boolean;

1283 }

1284 interface EditorUi extends EditorUiApi {

1285 registry: Registry;

1286 styleSheetLoader: StyleSheetLoader;

1287 }

1288 type Ui_d_Registry = Registry;

1289 type Ui_d_EditorUiApi = EditorUiApi;

1290 type Ui_d_EditorUi = EditorUi;

1291 declare namespace Ui_d {

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

1293 }

1294 interface WindowParams {

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

1296 readonly ariaAttrs?: boolean;

1297 }

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

1299 interface WindowManagerImpl {

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

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

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

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

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

1305 }

1306 interface WindowManager {

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

1308 openUrl: (config: UrlDialogSpec) => UrlDialogInstanceApi;

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

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

1311 close: () => void;

1312 }

1313 interface ExecCommandEvent {

1314 command: string;

1315 ui?: boolean;

1316 value?: any;

1317 }

1318 interface BeforeGetContentEvent extends GetContentArgs {

1319 selection?: boolean;

1320 }

1321 interface GetContentEvent extends BeforeGetContentEvent {

1322 content: string;

1323 }

1324 interface BeforeSetContentEvent extends SetContentArgs {

1325 content: string;

1326 selection?: boolean;

1327 }

1328 interface SetContentEvent extends BeforeSetContentEvent {

1329 content: string;

1330 }

1331 interface NewBlockEvent {

1332 newBlock: Element;

1333 }

1334 interface NodeChangeEvent {

1335 element: Element;

1336 parents: Node[];

1337 selectionChange?: boolean;

1338 initial?: boolean;

1339 }

1340 interface FormatEvent {

1341 format: string;

1342 vars?: FormatVars;

1343 node?: Node | RangeLikeObject;

1344 }

1345 interface ObjectResizeEvent {

1346 target: HTMLElement;

1347 width: number;

1348 height: number;

1349 origin: string;

1350 }

1351 interface ObjectSelectedEvent {

1352 target: Node;

1353 targetClone?: Node;

1354 }

1355 interface ScrollIntoViewEvent {

1356 elm: HTMLElement;

1357 alignToTop: boolean;

1358 }

1359 interface SetSelectionRangeEvent {

1360 range: Range;

1361 forward: boolean;

1362 }

1363 interface ShowCaretEvent {

1364 target: Node;

1365 direction: number;

1366 before: boolean;

1367 }

1368 interface SwitchModeEvent {

1369 mode: string;

1370 }

1371 interface AddUndoEvent {

1372 level: UndoLevel;

1373 lastLevel: UndoLevel;

1374 originalEvent: Event;

1375 }

1376 interface UndoRedoEvent {

1377 level: UndoLevel;

1378 }

1379 interface WindowEvent<T extends DialogData> {

1380 dialog: InstanceApi<T>;

1381 }

1382 interface ProgressStateEvent {

1383 state: boolean;

1384 time?: number;

1385 }

1386 interface AfterProgressStateEvent {

1387 state: boolean;

1388 }

1389 interface PlaceholderToggleEvent {

1390 state: boolean;

1391 }

1392 interface LoadErrorEvent {

1393 message: string;

1394 }

1395 interface PreProcessEvent extends ParserArgs {

1396 node: Element;

1397 }

1398 interface PostProcessEvent extends ParserArgs {

1399 content: string;

1400 }

1401 interface PastePlainTextToggleEvent {

1402 state: boolean;

1403 }

1404 interface PastePreProcessEvent {

1405 content: string;

1406 readonly internal: boolean;

1407 }

1408 interface PastePostProcessEvent {

1409 node: HTMLElement;

1410 readonly internal: boolean;

1411 }

1412 interface NewTableRowEvent {

1413 node: HTMLTableRowElement;

1414 }

1415 interface NewTableCellEvent {

1416 node: HTMLTableCellElement;

1417 }

1418 interface TableEventData {

1419 readonly structure: boolean;

1420 readonly style: boolean;

1421 }

1422 interface TableModifiedEvent extends TableEventData {

1423 readonly table: HTMLTableElement;

1424 }

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

1426 'activate': {

1427 relatedTarget: Editor;

1428 };

1429 'deactivate': {

1430 relatedTarget: Editor;

1431 };

1432 'focus': {

1433 blurredEditor: Editor;

1434 };

1435 'blur': {

1436 focusedEditor: Editor;

1437 };

1438 'resize': UIEvent;

1439 'scroll': UIEvent;

1440 'detach': {};

1441 'remove': {};

1442 'init': {};

1443 'ScrollIntoView': ScrollIntoViewEvent;

1444 'AfterScrollIntoView': ScrollIntoViewEvent;

1445 'ObjectResized': ObjectResizeEvent;

1446 'ObjectResizeStart': ObjectResizeEvent;

1447 'SwitchMode': SwitchModeEvent;

1448 'ScrollWindow': UIEvent;

1449 'ResizeWindow': UIEvent;

1450 'SkinLoaded': {};

1451 'SkinLoadError': LoadErrorEvent;

1452 'PluginLoadError': LoadErrorEvent;

1453 'ModelLoadError': LoadErrorEvent;

1454 'IconsLoadError': LoadErrorEvent;

1455 'ThemeLoadError': LoadErrorEvent;

1456 'LanguageLoadError': LoadErrorEvent;

1457 'BeforeExecCommand': ExecCommandEvent;

1458 'ExecCommand': ExecCommandEvent;

1459 'NodeChange': NodeChangeEvent;

1460 'FormatApply': FormatEvent;

1461 'FormatRemove': FormatEvent;

1462 'ShowCaret': ShowCaretEvent;

1463 'SelectionChange': {};

1464 'ObjectSelected': ObjectSelectedEvent;

1465 'BeforeObjectSelected': ObjectSelectedEvent;

1466 'GetSelectionRange': {

1467 range: Range;

1468 };

1469 'SetSelectionRange': SetSelectionRangeEvent;

1470 'AfterSetSelectionRange': SetSelectionRangeEvent;

1471 'BeforeGetContent': BeforeGetContentEvent;

1472 'GetContent': GetContentEvent;

1473 'BeforeSetContent': BeforeSetContentEvent;

1474 'SetContent': SetContentEvent;

1475 'LoadContent': {};

1476 'PreviewFormats': {};

1477 'AfterPreviewFormats': {};

1478 'ScriptsLoaded': {};

1479 'PreInit': {};

1480 'PostRender': {};

1481 'NewBlock': NewBlockEvent;

1482 'ClearUndos': {};

1483 'TypingUndo': {};

1484 'Redo': UndoRedoEvent;

1485 'Undo': UndoRedoEvent;

1486 'BeforeAddUndo': AddUndoEvent;

1487 'AddUndo': AddUndoEvent;

1488 'CloseWindow': WindowEvent<any>;

1489 'OpenWindow': WindowEvent<any>;

1490 'ProgressState': ProgressStateEvent;

1491 'AfterProgressState': AfterProgressStateEvent;

1492 'PlaceholderToggle': PlaceholderToggleEvent;

1493 'tap': TouchEvent;

1494 'longpress': TouchEvent;

1495 'longpresscancel': {};

1496 'PreProcess': PreProcessEvent;

1497 'PostProcess': PostProcessEvent;

1498 'AutocompleterStart': AutocompleterEventArgs;

1499 'AutocompleterUpdate': AutocompleterEventArgs;

1500 'AutocompleterEnd': {};

1501 'PastePlainTextToggle': PastePlainTextToggleEvent;

1502 'PastePreProcess': PastePreProcessEvent;

1503 'PastePostProcess': PastePostProcessEvent;

1504 'TableModified': TableModifiedEvent;

1505 'NewRow': NewTableRowEvent;

1506 'NewCell': NewTableCellEvent;

1507 }

1508 interface EditorManagerEventMap {

1509 'AddEditor': {

1510 editor: Editor;

1511 };

1512 'RemoveEditor': {

1513 editor: Editor;

1514 };

1515 'BeforeUnload': {

1516 returnValue: any;

1517 };

1518 }

1519 type EventTypes_d_ExecCommandEvent = ExecCommandEvent;

1520 type EventTypes_d_BeforeGetContentEvent = BeforeGetContentEvent;

1521 type EventTypes_d_GetContentEvent = GetContentEvent;

1522 type EventTypes_d_BeforeSetContentEvent = BeforeSetContentEvent;

1523 type EventTypes_d_SetContentEvent = SetContentEvent;

1524 type EventTypes_d_NewBlockEvent = NewBlockEvent;

1525 type EventTypes_d_NodeChangeEvent = NodeChangeEvent;

1526 type EventTypes_d_FormatEvent = FormatEvent;

1527 type EventTypes_d_ObjectResizeEvent = ObjectResizeEvent;

1528 type EventTypes_d_ObjectSelectedEvent = ObjectSelectedEvent;

1529 type EventTypes_d_ScrollIntoViewEvent = ScrollIntoViewEvent;

1530 type EventTypes_d_SetSelectionRangeEvent = SetSelectionRangeEvent;

1531 type EventTypes_d_ShowCaretEvent = ShowCaretEvent;

1532 type EventTypes_d_SwitchModeEvent = SwitchModeEvent;

1533 type EventTypes_d_AddUndoEvent = AddUndoEvent;

1534 type EventTypes_d_UndoRedoEvent = UndoRedoEvent;

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

1536 type EventTypes_d_ProgressStateEvent = ProgressStateEvent;

1537 type EventTypes_d_AfterProgressStateEvent = AfterProgressStateEvent;

1538 type EventTypes_d_PlaceholderToggleEvent = PlaceholderToggleEvent;

1539 type EventTypes_d_LoadErrorEvent = LoadErrorEvent;

1540 type EventTypes_d_PreProcessEvent = PreProcessEvent;

1541 type EventTypes_d_PostProcessEvent = PostProcessEvent;

1542 type EventTypes_d_PastePlainTextToggleEvent = PastePlainTextToggleEvent;

1543 type EventTypes_d_PastePreProcessEvent = PastePreProcessEvent;

1544 type EventTypes_d_PastePostProcessEvent = PastePostProcessEvent;

1545 type EventTypes_d_NewTableRowEvent = NewTableRowEvent;

1546 type EventTypes_d_NewTableCellEvent = NewTableCellEvent;

1547 type EventTypes_d_TableEventData = TableEventData;

1548 type EventTypes_d_TableModifiedEvent = TableModifiedEvent;

1549 type EventTypes_d_EditorEventMap = EditorEventMap;

1550 type EventTypes_d_EditorManagerEventMap = EditorManagerEventMap;

1551 declare namespace EventTypes_d {

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

1553 }

1554 type Format_d_Formats = Formats;

1555 type Format_d_Format = Format;

1556 type Format_d_ApplyFormat = ApplyFormat;

1557 type Format_d_BlockFormat = BlockFormat;

1558 type Format_d_InlineFormat = InlineFormat;

1559 type Format_d_SelectorFormat = SelectorFormat;

1560 type Format_d_RemoveFormat = RemoveFormat;

1561 type Format_d_RemoveBlockFormat = RemoveBlockFormat;

1562 type Format_d_RemoveInlineFormat = RemoveInlineFormat;

1563 type Format_d_RemoveSelectorFormat = RemoveSelectorFormat;

1564 declare namespace Format_d {

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

1566 }

1567 declare type StyleFormat = BlockStyleFormat | InlineStyleFormat | SelectorStyleFormat;

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

1569 interface Separator {

1570 title: string;

1571 }

1572 interface FormatReference {

1573 title: string;

1574 format: string;

1575 icon?: string;

1576 }

1577 interface NestedFormatting {

1578 title: string;

1579 items: Array<FormatReference | StyleFormat>;

1580 }

1581 interface CommonStyleFormat {

1582 name?: string;

1583 title: string;

1584 icon?: string;

1585 }

1586 interface BlockStyleFormat extends BlockFormat, CommonStyleFormat {

1587 }

1588 interface InlineStyleFormat extends InlineFormat, CommonStyleFormat {

1589 }

1590 interface SelectorStyleFormat extends SelectorFormat, CommonStyleFormat {

1591 }

1593 interface ContentLanguage {

1594 readonly title: string;

1595 readonly code: string;

1596 readonly customCode?: string;

1597 }

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

1599 editorContainer: HTMLElement;

1600 iframeContainer: HTMLElement;

1601 height?: number;

1602 iframeHeight?: number;

1603 api?: EditorUiApi;

1604 };

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

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

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

1608 declare type FilePickerValidationCallback = (info: {

1609 type: string;

1610 url: string;

1611 }, callback: (validation: {

1612 status: FilePickerValidationStatus;

1613 message: string;

1614 }) => void) => void;

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

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

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

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

1619 interface ToolbarGroup {

1620 name?: string;

1621 items: string[];

1622 }

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

1624 interface BaseEditorOptions {

1625 a11y_advanced_options?: boolean;

1626 add_form_submit_trigger?: boolean;

1627 add_unload_trigger?: boolean;

1628 allow_conditional_comments?: boolean;

1629 allow_html_data_urls?: boolean;

1630 allow_html_in_named_anchor?: boolean;

1631 allow_script_urls?: boolean;

1632 allow_svg_data_urls?: boolean;

1633 allow_unsafe_link_target?: boolean;

1634 anchor_bottom?: false | string;

1635 anchor_top?: false | string;

1636 auto_focus?: string | true;

1637 automatic_uploads?: boolean;

1638 base_url?: string;

1639 block_formats?: string;

1640 block_unsupported_drop?: boolean;

1641 body_id?: string;

1642 body_class?: string;

1643 br_in_pre?: boolean;

1644 br_newline_selector?: string;

1645 browser_spellcheck?: boolean;

1646 branding?: boolean;

1647 cache_suffix?: string;

1648 color_cols?: number;

1649 color_map?: string[];

1650 content_css?: boolean | string | string[];

1651 content_css_cors?: boolean;

1652 content_security_policy?: string;

1653 content_style?: string;

1654 content_langs?: ContentLanguage[];

1655 contextmenu?: string | string[] | false;

1656 contextmenu_never_use_native?: boolean;

1657 convert_fonts_to_spans?: boolean;

1658 convert_urls?: boolean;

1659 custom_colors?: boolean;

1660 custom_elements?: string;

1661 custom_ui_selector?: string;

1662 custom_undo_redo_levels?: number;

1663 deprecation_warnings?: boolean;

1664 directionality?: 'ltr' | 'rtl';

1665 doctype?: string;

1666 document_base_url?: string;

1667 editable_class?: string;

1668 element_format?: 'xhtml' | 'html';

1669 elementpath?: boolean;

1670 encoding?: string;

1671 end_container_on_empty_block?: boolean | string;

1672 entities?: string;

1673 entity_encoding?: EntityEncoding;

1674 extended_valid_elements?: string;

1675 event_root?: string;

1676 file_picker_callback?: FilePickerCallback;

1677 file_picker_types?: string;

1678 file_picker_validator_handler?: FilePickerValidationCallback;

1679 fix_list_elements?: boolean;

1680 fixed_toolbar_container?: string;

1681 fixed_toolbar_container_target?: HTMLElement;

1682 font_css?: string | string[];

1683 font_family_formats?: string;

1684 font_size_classes?: string;

1685 font_size_legacy_values?: string;

1686 font_size_style_values?: string;

1687 font_size_formats?: string;

1688 forced_root_block?: string;

1689 forced_root_block_attrs?: Record<string, string>;

1690 formats?: Formats;

1691 height?: number | string;

1692 hidden_input?: boolean;

1693 icons?: string;

1694 icons_url?: string;

1695 id?: string;

1696 iframe_aria_text?: string;

1697 iframe_attrs?: Record<string, string>;

1698 images_file_types?: string;

1699 images_replace_blob_uris?: boolean;

1700 images_reuse_filename?: boolean;

1701 images_upload_base_path?: string;

1702 images_upload_credentials?: boolean;

1703 images_upload_handler?: UploadHandler;

1704 images_upload_url?: string;

1705 indent?: boolean;

1706 indent_after?: string;

1707 indent_before?: string;

1708 indent_use_margin?: boolean;

1709 indentation?: string;

1710 init_instance_callback?: SetupCallback;

1711 inline?: boolean;

1712 inline_boundaries?: boolean;

1713 inline_boundaries_selector?: string;

1714 inline_styles?: boolean;

1715 invalid_elements?: string;

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

1717 keep_styles?: boolean;

1718 language?: string;

1719 language_load?: boolean;

1720 language_url?: string;

1721 line_height_formats?: string;

1722 max_height?: number;

1723 max_width?: number;

1724 menu?: Record<string, {

1725 title: string;

1726 items: string;

1727 }>;

1728 menubar?: boolean | string;

1729 min_height?: number;

1730 min_width?: number;

1731 model?: string;

1732 model_url?: string;

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

1734 no_newline_selector?: string;

1735 noneditable_class?: string;

1736 noneditable_regexp?: RegExp | RegExp[];

1737 nowrap?: boolean;

1738 object_resizing?: boolean | string;

1739 paste_as_text?: boolean;

1740 paste_block_drop?: boolean;

1741 paste_data_images?: boolean;

1742 paste_merge_formats?: boolean;

1743 paste_postprocess?: PastePostProcessFn;

1744 paste_preprocess?: PastePreProcessFn;

1745 paste_remove_styles_if_webkit?: boolean;

1746 paste_tab_spaces?: number;

1747 paste_webkit_styles?: string;

1748 placeholder?: string;

1749 preserve_cdata?: boolean;

1750 preview_styles?: false | string;

1751 protect?: RegExp[];

1752 readonly?: boolean;

1753 referrer_policy?: ReferrerPolicy;

1754 relative_urls?: boolean;

1755 remove_script_host?: boolean;

1756 remove_trailing_brs?: boolean;

1757 removed_menuitems?: string;

1758 resize?: boolean | 'both';

1759 resize_img_proportional?: boolean;

1760 root_name?: string;

1761 schema?: SchemaType;

1762 selector?: string;

1763 setup?: SetupCallback;

1764 sidebar_show?: string;

1765 skin?: boolean | string;

1766 skin_url?: string;

1767 smart_paste?: boolean;

1768 statusbar?: boolean;

1769 style_formats?: AllowedFormat[];

1770 style_formats_autohide?: boolean;

1771 style_formats_merge?: boolean;

1772 submit_patch?: boolean;

1773 suffix?: string;

1774 table_tab_navigation?: boolean;

1775 target?: HTMLElement;

1776 text_patterns?: RawPattern[] | false;

1777 theme?: string | ThemeInitFunc | false;

1778 theme_url?: string;

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

1780 toolbar1?: string;

1781 toolbar2?: string;

1782 toolbar3?: string;

1783 toolbar4?: string;

1784 toolbar5?: string;

1785 toolbar6?: string;

1786 toolbar7?: string;

1787 toolbar8?: string;

1788 toolbar9?: string;

1789 toolbar_mode?: ToolbarMode;

1790 toolbar_sticky?: boolean;

1791 toolbar_sticky_offset?: number;

1792 typeahead_urls?: boolean;

1793 url_converter?: URLConverter;

1794 url_converter_scope?: any;

1795 urlconverter_callback?: URLConverterCallback;

1796 valid_children?: string;

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

1798 valid_elements?: string;

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

1800 verify_html?: boolean;

1801 visual?: boolean;

1802 visual_anchor_class?: string;

1803 visual_table_class?: string;

1804 width?: number | string;

1805 disable_nodechange?: boolean;

1806 forced_plugins?: string | string[];

1807 plugin_base_urls?: Record<string, string>;

1808 service_message?: string;

1809 [key: string]: any;

1810 }

1811 interface RawEditorOptions extends BaseEditorOptions {

1812 external_plugins?: Record<string, string>;

1813 mobile?: RawEditorOptions;

1814 plugins?: string | string[];

1815 }

1816 interface NormalizedEditorOptions extends BaseEditorOptions {

1817 external_plugins: Record<string, string>;

1818 forced_plugins: string[];

1819 plugins: string[];

1820 }

1821 interface EditorOptions extends NormalizedEditorOptions {

1822 content_css: string[];

1823 contextmenu: string[];

1824 font_css: string[];

1825 forced_root_block: string;

1826 forced_root_block_attrs: Record<string, string>;

1827 noneditable_regexp: RegExp[];

1828 object_resizing?: string;

1829 preview_styles?: string;

1830 text_patterns?: Pattern[];

1831 }

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

1833 interface StylesSettings {

1834 allow_script_urls?: boolean;

1835 allow_svg_data_urls?: boolean;

1836 url_converter?: URLConverter;

1837 url_converter_scope?: any;

1838 }

1839 interface Styles {

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

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

1842 }

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

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

1845 metaKey: boolean;

1846 };

1847 interface EventUtilsConstructor {

1848 readonly prototype: EventUtils;

1849 new (): EventUtils;

1850 Event: EventUtils;

1851 }

1852 declare class EventUtils {

1853 static Event: EventUtils;

1854 domLoaded: boolean;

1855 events: Record<string, any>;

1856 private readonly expando;

1857 private hasFocusIn;

1858 private hasMouseEnterLeave;

1859 private mouseEnterLeave;

1860 private count;

1861 constructor();

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

1863 bind<T = any>(target: any, names: string, callback: EventUtilsCallback<T>, scope?: any): EventUtilsCallback<T>;

1864 unbind<K extends keyof HTMLElementEventMap>(target: any, name: K, callback?: EventUtilsCallback<HTMLElementEventMap[K]>): this;

1865 unbind<T = any>(target: any, names: string, callback?: EventUtilsCallback<T>): this;

1866 unbind(target: any): this;

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

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

1869 clean(target: any): this;

1870 destroy(): void;

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

1872 private executeHandlers;

1873 }

1874 interface DOMUtilsSettings {

1875 schema: Schema;

1876 url_converter: URLConverter;

1877 url_converter_scope: any;

1878 ownEvents: boolean;

1879 keep_values: boolean;

1880 update_styles: boolean;

1881 root_element: HTMLElement;

1882 collect: Function;

1883 onSetAttrib: Function;

1884 contentCssCors: boolean;

1885 referrerPolicy: ReferrerPolicy;

1886 }

1887 declare type Target = Node | Window;

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

1889 declare type BoundEvent = [

1890 Target,

1891 string,

1892 EventUtilsCallback<any>,

1893 any

1894 ];

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

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

1897 interface DOMUtils {

1898 doc: Document;

1899 settings: Partial<DOMUtilsSettings>;

1900 win: Window;

1901 files: Record<string, boolean>;

1902 stdMode: boolean;

1903 boxModel: boolean;

1904 styleSheetLoader: StyleSheetLoader;

1905 boundEvents: BoundEvent[];

1906 styles: Styles;

1907 schema: Schema;

1908 events: EventUtils;

1909 root: Node;

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

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

1912 getRoot: () => HTMLElement;

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

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

1915 getSize: (elm: string | HTMLElement) => {

1916 w: number;

1917 h: number;

1918 };

1919 getParent: {

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

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

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

1923 };

1924 getParents: {

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

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

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

1928 };

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

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

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

1932 select: {

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

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

1935 };

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

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

1938 create: {

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

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

1941 };

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

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

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

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

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

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

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

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

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

1953 x: number;

1954 y: number;

1955 };

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

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

1958 addStyle: (cssText: string) => void;

1959 loadCSS: (url: string) => void;

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

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

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

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

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

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

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

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

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

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

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

1971 decode: (text: string) => string;

1972 encode: (text: string) => string;

1973 insertAfter: {

1974 <T extends Node>(node: T | T[], reference: string | Node): T;

1975 <T extends Node>(node: RunArguments<T>, reference: string | Node): RunResult<typeof node, T>;

1976 };

1977 replace: {

1978 <T extends Node>(newElm: Node, oldElm: T | T[], keepChildren?: boolean): T;

1979 <T extends Node>(newElm: Node, oldElm: RunArguments<T>, keepChildren?: boolean): false | T;

1980 };

1981 rename: {

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

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

1984 };

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

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

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

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

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

1990 createRng: () => Range;

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

1992 split: {

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

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

1995 };

1996 bind: {

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

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

1999 };

2000 unbind: {

2001 <K extends string>(target: Target, name?: K, func?: EventUtilsCallback<MappedEvent<HTMLElementEventMap, K>>): EventUtils;

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

2003 };

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

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

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

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

2008 destroy: () => void;

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

2010 dumpRng: (r: Range) => string;

2011 }

2012 interface ClientRect {

2013 left: number;

2014 top: number;

2015 bottom: number;

2016 right: number;

2017 width: number;

2018 height: number;

2019 }

2020 interface BookmarkManager {

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

2022 moveToBookmark: (bookmark: Bookmark) => void;

2023 }

2024 interface ControlSelection {

2025 isResizable: (elm: Element) => boolean;

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

2027 hideResizeRect: () => void;

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

2029 destroy: () => void;

2030 }

2031 interface WriterSettings {

2032 element_format?: 'xhtml' | 'html';

2033 entities?: string;

2034 entity_encoding?: EntityEncoding;

2035 indent?: boolean;

2036 indent_after?: string;

2037 indent_before?: string;

2038 }

2039 declare type Attributes = Array<{

2040 name: string;

2041 value: string;

2042 }>;

2043 interface Writer {

2044 cdata: (text: string) => void;

2045 comment: (text: string) => void;

2046 doctype: (text: string) => void;

2047 end: (name: string) => void;

2048 getContent: () => string;

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

2050 reset: () => void;

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

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

2053 }

2054 interface HtmlSerializerSettings extends WriterSettings {

2055 inner?: boolean;

2056 validate?: boolean;

2057 }

2058 interface HtmlSerializer {

2059 serialize: (node: AstNode) => string;

2060 }

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

2062 url_converter?: URLConverter;

2063 url_converter_scope?: {};

2064 }

2065 interface DomSerializerImpl {

2066 schema: Schema;

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

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

2069 getNodeFilters: () => ParserFilter[];

2070 getAttributeFilters: () => ParserFilter[];

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

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

2073 serialize: {

2074 (node: Element, parserArgs: {

2075 format: 'tree';

2076 } & ParserArgs): AstNode;

2077 (node: Element, parserArgs?: ParserArgs): string;

2078 };

2079 addRules: (rules: string) => void;

2080 setRules: (rules: string) => void;

2081 addTempAttr: (name: string) => void;

2082 getTempAttrs: () => string[];

2083 }

2084 interface DomSerializer extends DomSerializerImpl {

2085 }

2086 interface EditorSelection {

2087 bookmarkManager: BookmarkManager;

2088 controlSelection: ControlSelection;

2089 dom: DOMUtils;

2090 win: Window;

2091 serializer: DomSerializer;

2092 editor: Editor;

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

2094 setCursorLocation: {

2095 (node: Node, offset: number): void;

2096 (): void;

2097 };

2098 getContent: {

2099 (args: {

2100 format: 'tree';

2101 } & Partial<GetSelectionContentArgs>): AstNode;

2102 (args?: Partial<GetSelectionContentArgs>): string;

2103 };

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

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

2106 moveToBookmark: (bookmark: Bookmark) => void;

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

2108 isCollapsed: () => boolean;

2109 isForward: () => boolean;

2110 setNode: (elm: Element) => Element;

2111 getNode: () => Element;

2112 getSel: () => Selection | null;

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

2114 getRng: () => Range;

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

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

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

2118 normalize: () => Range;

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

2120 node: Node;

2121 selector: String;

2122 parents: Element[];

2123 }) => void) => EditorSelection;

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

2125 node: Node;

2126 selector: String;

2127 parents: Element[];

2128 }) => void) => {

2129 unbind: () => void;

2130 };

2131 getScrollContainer: () => HTMLElement;

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

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

2134 getBoundingClientRect: () => ClientRect | DOMRect;

2135 destroy: () => void;

2136 }

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

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

2139 interface Commands {

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

2141 exec: Record<string, EditorCommandsCallback>;

2142 value: Record<string, (command: string) => string>;

2143 }

2144 interface ExecCommandArgs {

2145 skip_focus?: boolean;

2146 }

2147 interface EditorCommandsConstructor {

2148 readonly prototype: EditorCommands;

2149 new (editor: Editor): EditorCommands;

2150 }

2151 declare class EditorCommands {

2152 private readonly editor;

2153 private commands;

2154 constructor(editor: Editor);

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

2156 queryCommandState(command: string): boolean;

2157 queryCommandValue(command: string): string;

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

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

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

2161 queryCommandSupported(command: string): boolean;

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

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

2164 }

2165 interface RawString {

2166 raw: string;

2167 }

2169 declare type TokenisedString = [

2170 string,

2171 ...Primitive[]

2172 ];

2173 declare type Untranslated = Primitive | TokenisedString | RawString;

2174 declare type TranslatedString = string;

2175 interface I18n {

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

2177 setCode: (newCode: string) => void;

2178 getCode: () => string;

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

2180 translate: (text: Untranslated) => TranslatedString;

2181 isRtl: () => boolean;

2182 hasCode: (code: string) => boolean;

2183 }

2184 interface Observable<T> {

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

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

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

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

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

2190 hasEventListeners(name: string): boolean;

2191 }

2192 interface URISettings {

2193 base_uri?: URI;

2194 }

2195 interface URIConstructor {

2196 readonly prototype: URI;

2197 new (url: string, settings?: URISettings): URI;

2198 getDocumentBaseUrl: (loc: {

2199 protocol: string;

2200 host?: string;

2201 href?: string;

2202 pathname?: string;

2203 }) => string;

2204 parseDataUri: (uri: string) => {

2205 type: string;

2206 data: string;

2207 };

2208 }

2209 interface SafeUriOptions {

2210 readonly allow_html_data_urls?: boolean;

2211 readonly allow_script_urls?: boolean;

2212 readonly allow_svg_data_urls?: boolean;

2213 }

2214 declare class URI {

2215 static parseDataUri(uri: string): {

2216 type: string;

2217 data: string;

2218 };

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

2220 static getDocumentBaseUrl(loc: {

2221 protocol: string;

2222 host?: string;

2223 href?: string;

2224 pathname?: string;

2225 }): string;

2226 source: string;

2227 protocol: string;

2228 authority: string;

2229 userInfo: string;

2230 user: string;

2231 password: string;

2232 host: string;

2233 port: string;

2234 relative: string;

2235 path: string;

2236 directory: string;

2237 file: string;

2238 query: string;

2239 anchor: string;

2240 settings: URISettings;

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

2242 setPath(path: string): void;

2243 toRelative(uri: string): string;

2244 toAbsolute(uri: string, noHost?: boolean): string;

2245 isSameOrigin(uri: URI): boolean;

2246 toRelPath(base: string, path: string): string;

2247 toAbsPath(base: string, path: string): string;

2248 getURI(noProtoHost?: boolean): string;

2249 }

2250 interface EditorManager extends Observable<EditorManagerEventMap> {

2251 defaultOptions: RawEditorOptions;

2252 majorVersion: string;

2253 minorVersion: string;

2254 releaseDate: string;

2255 activeEditor: Editor;

2256 focusedEditor: Editor;

2257 baseURI: URI;

2258 baseURL: string;

2259 documentBaseURL: string;

2260 i18n: I18n;

2261 suffix: string;

2262 add(this: EditorManager, editor: Editor): Editor;

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

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

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

2266 get(this: EditorManager): Editor[];

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

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

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

2270 remove(this: EditorManager): void;

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

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

2273 setup(this: EditorManager): void;

2274 translate: (text: Untranslated) => TranslatedString;

2275 triggerSave: () => void;

2276 _setBaseUrl(this: EditorManager, baseUrl: string): void;

2277 }

2278 interface EditorObservable extends Observable<EditorEventMap> {

2279 bindPendingEventDelegates(this: Editor): void;

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

2281 unbindAllNativeEvents(this: Editor): void;

2282 }

2283 interface ProcessorSuccess<T> {

2284 valid: true;

2285 value: T;

2286 }

2287 interface ProcessorError {

2288 valid: false;

2289 message: string;

2290 }

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

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

2293 interface BuiltInOptionTypeMap {

2294 'string': string;

2295 'number': number;

2296 'boolean': boolean;

2297 'array': any[];

2298 'function': Function;

2299 'object': any;

2300 'string[]': string[];

2301 'object[]': any[];

2302 'regexp': RegExp;

2303 }

2304 declare type BuiltInOptionType = keyof BuiltInOptionTypeMap;

2305 interface BaseOptionSpec {

2306 immutable?: boolean;

2307 deprecated?: boolean;

2308 docsUrl?: string;

2309 }

2310 interface BuiltInOptionSpec<K extends BuiltInOptionType> extends BaseOptionSpec {

2311 processor: K;

2312 default?: BuiltInOptionTypeMap[K];

2313 }

2314 interface SimpleOptionSpec<T> extends BaseOptionSpec {

2315 processor: SimpleProcessor;

2316 default?: T;

2317 }

2318 interface OptionSpec<T, U> extends BaseOptionSpec {

2319 processor: Processor;

2320 default?: T;

2321 }

2322 interface Options {

2323 register: {

2324 <K extends BuiltInOptionType>(name: string, spec: BuiltInOptionSpec<K>): void;

2325 <K extends keyof NormalizedEditorOptions>(name: K, spec: OptionSpec<NormalizedEditorOptions[K], EditorOptions[K]> | SimpleOptionSpec<NormalizedEditorOptions[K]>): void;

2326 <T, U>(name: string, spec: OptionSpec<T, U>): void;

2327 <T>(name: string, spec: SimpleOptionSpec<T>): void;

2328 };

2329 isRegistered: (name: string) => boolean;

2330 get: {

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

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

2333 };

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

2335 unset: (name: string) => boolean;

2336 isSet: (name: string) => boolean;

2337 }

2338 interface UploadResult$1 {

2339 element: HTMLImageElement;

2340 status: boolean;

2341 blobInfo: BlobInfo;

2342 uploadUri: string;

2343 removed: boolean;

2344 }

2345 interface EditorUpload {

2346 blobCache: BlobCache;

2347 addFilter: (filter: (img: HTMLImageElement) => boolean) => void;

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

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

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

2351 destroy: () => void;

2352 }

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

2354 node: Node;

2355 format: string;

2356 parents: any;

2357 }) => void;

2358 interface FormatRegistry {

2359 get: {

2360 (name: string): Format[] | undefined;

2361 (): Record<string, Format[]>;

2362 };

2363 has: (name: string) => boolean;

2364 register: (name: string | Formats, format?: Format[] | Format) => void;

2365 unregister: (name: string) => Formats;

2366 }

2367 interface Formatter extends FormatRegistry {

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

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

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

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

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

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

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

2375 canApply: (name: string) => boolean;

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

2377 unbind: () => void;

2378 };

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

2380 }

2381 interface EditorMode {

2382 isReadOnly: () => boolean;

2383 set: (mode: string) => void;

2384 get: () => string;

2385 register: (mode: string, api: EditorModeApi) => void;

2386 }

2387 interface EditorModeApi {

2388 activate: () => void;

2389 deactivate: () => void;

2390 editorReadOnly: boolean;

2391 }

2392 interface Model {

2393 readonly table: {

2394 readonly getSelectedCells: () => HTMLTableCellElement[];

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

2396 };

2397 }

2398 declare type ModelManager = AddOnManager<Model>;

2399 interface Plugin {

2400 getMetadata?: () => {

2401 name: string;

2402 url: string;

2403 };

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

2405 [key: string]: any;

2406 }

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

2408 interface ShortcutsConstructor {

2409 readonly prototype: Shortcuts;

2410 new (editor: Editor): Shortcuts;

2411 }

2412 declare type CommandFunc = string | [

2413 string,

2414 boolean,

2415 any

2416 ] | (() => void);

2417 declare class Shortcuts {

2418 private readonly editor;

2419 private readonly shortcuts;

2420 private pendingPatterns;

2421 constructor(editor: Editor);

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

2423 remove(pattern: string): boolean;

2424 private normalizeCommandFunc;

2425 private createShortcut;

2426 private hasModifier;

2427 private isFunctionKey;

2428 private matchShortcut;

2429 private executeShortcutAction;

2430 }

2431 interface Theme {

2432 ui?: any;

2433 inline?: any;

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

2435 destroy?: () => void;

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

2437 renderUI?: () => {

2438 iframeContainer?: HTMLIFrameElement;

2439 editorContainer: HTMLElement;

2440 api?: Partial<EditorUiApi>;

2441 };

2442 getNotificationManagerImpl?: () => NotificationManagerImpl;

2443 getWindowManagerImpl?: () => WindowManagerImpl;

2444 }

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

2446 interface EditorConstructor {

2447 readonly prototype: Editor;

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

2449 }

2450 declare class Editor implements EditorObservable {

2451 documentBaseUrl: string;

2452 baseUri: URI;

2453 id: string;

2454 plugins: Record<string, Plugin>;

2455 documentBaseURI: URI;

2456 baseURI: URI;

2457 contentCSS: string[];

2458 contentStyles: string[];

2459 ui: EditorUi;

2460 mode: EditorMode;

2461 options: Options;

2462 shortcuts: Shortcuts;

2463 loadedCSS: Record<string, any>;

2464 editorCommands: EditorCommands;

2465 suffix: string;

2466 editorManager: EditorManager;

2467 inline: boolean;

2468 isNotDirty: boolean;

2469 annotator: Annotator;

2470 bodyElement: HTMLElement;

2471 bookmark: any;

2472 composing: boolean;

2473 container: HTMLElement;

2474 contentAreaContainer: HTMLElement;

2475 contentDocument: Document;

2476 contentWindow: Window;

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

2478 destroyed: boolean;

2479 dom: DOMUtils;

2480 editorContainer: HTMLElement;

2481 editorUpload: EditorUpload;

2482 eventRoot?: Element;

2483 formatter: Formatter;

2484 formElement: HTMLElement;

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

2486 hasHiddenInput: boolean;

2487 hasVisual: boolean;

2488 hidden: boolean;

2489 iframeElement: HTMLIFrameElement | null;

2490 iframeHTML: string;

2491 initialized: boolean;

2492 notificationManager: NotificationManager;

2493 orgDisplay: string;

2494 orgVisibility: string;

2495 parser: DomParser;

2496 quirks: Quirks;

2497 readonly: boolean;

2498 removed: boolean;

2499 schema: Schema;

2500 selection: EditorSelection;

2501 serializer: DomSerializer;

2502 startContent: string;

2503 targetElm: HTMLElement;

2504 theme: Theme;

2505 model: Model;

2506 undoManager: UndoManager;

2507 windowManager: WindowManager;

2508 _beforeUnload: () => void;

2509 _eventDispatcher: EventDispatcher<NativeEventMap>;

2510 _nodeChangeDispatcher: NodeChange;

2511 _pendingNativeEvents: string[];

2512 _selectionOverrides: SelectionOverrides;

2513 _skinLoaded: boolean;

2514 bindPendingEventDelegates: EditorObservable['bindPendingEventDelegates'];

2515 toggleNativeEvent: EditorObservable['toggleNativeEvent'];

2516 unbindAllNativeEvents: EditorObservable['unbindAllNativeEvents'];

2517 fire: EditorObservable['fire'];

2518 dispatch: EditorObservable['dispatch'];

2519 on: EditorObservable['on'];

2520 off: EditorObservable['off'];

2521 once: EditorObservable['once'];

2522 hasEventListeners: EditorObservable['hasEventListeners'];

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

2524 render(): void;

2525 focus(skipFocus?: boolean): void;

2526 hasFocus(): boolean;

2527 translate(text: Untranslated): TranslatedString;

2528 getParam<K extends BuiltInOptionType>(name: string, defaultVal: BuiltInOptionTypeMap[K], type: K): BuiltInOptionTypeMap[K];

2529 getParam<K extends keyof NormalizedEditorOptions>(name: K, defaultVal?: NormalizedEditorOptions[K], type?: BuiltInOptionType): NormalizedEditorOptions[K];

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

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

2532 nodeChanged(args?: any): void;

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

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

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

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

2537 string,

2538 boolean,

2539 any

2540 ] | (() => void), scope?: any): void;

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

2542 queryCommandState(cmd: string): boolean;

2543 queryCommandValue(cmd: string): string;

2544 queryCommandSupported(cmd: string): boolean;

2545 show(): void;

2546 hide(): void;

2547 isHidden(): boolean;

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

2549 load(args?: any): string;

2550 save(args?: any): string;

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

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

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

2554 getContent(args: {

2555 format: 'tree';

2556 } & Partial<GetContentArgs>): AstNode;

2557 getContent(args?: Partial<GetContentArgs>): string;

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

2559 resetContent(initialContent?: string): void;

2560 isDirty(): boolean;

2561 setDirty(state: boolean): void;

2562 getContainer(): HTMLElement;

2563 getContentAreaContainer(): HTMLElement;

2564 getElement(): HTMLElement;

2565 getWin(): Window;

2566 getDoc(): Document;

2567 getBody(): HTMLElement;

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

2569 addVisual(elm?: HTMLElement): void;

2570 remove(): void;

2571 destroy(automatic?: boolean): void;

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

2573 _scanForImages(): Promise<BlobInfoImagePair[]>;

2574 }

2575 interface UrlObject {

2576 prefix: string;

2577 resource: string;

2578 suffix: string;

2579 }

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

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

2582 interface AddOnManager<T> {

2583 items: AddOnConstructor<T>[];

2584 urls: Record<string, string>;

2585 lookup: Record<string, {

2586 instance: AddOnConstructor<T>;

2587 }>;

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

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

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

2591 remove: (name: string) => void;

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

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

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

2595 }

2596 interface RangeUtils {

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

2598 split: (rng: Range) => RangeLikeObject;

2599 normalize: (rng: Range) => boolean;

2600 }

2601 interface ScriptLoaderSettings {

2602 referrerPolicy?: ReferrerPolicy;

2603 }

2604 interface ScriptLoaderConstructor {

2605 readonly prototype: ScriptLoader;

2606 new (): ScriptLoader;

2607 ScriptLoader: ScriptLoader;

2608 }

2609 declare class ScriptLoader {

2610 static ScriptLoader: ScriptLoader;

2611 private settings;

2612 private states;

2613 private queue;

2614 private scriptLoadedCallbacks;

2615 private queueLoadedCallbacks;

2616 private loading;

2617 constructor(settings?: ScriptLoaderSettings);

2618 _setReferrerPolicy(referrerPolicy: ReferrerPolicy): void;

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

2620 isDone(url: string): boolean;

2621 markDone(url: string): void;

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

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

2624 remove(url: string): void;

2625 loadQueue(): Promise<void>;

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

2627 }

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

2629 interface Spot {

2630 container: Text;

2631 offset: number;

2632 }

2633 interface TextSeeker {

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

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

2636 }

2637 interface DomTreeWalkerConstructor {

2638 readonly prototype: DomTreeWalker;

2639 new (startNode: Node, rootNode: Node): DomTreeWalker;

2640 }

2641 declare class DomTreeWalker {

2642 private readonly rootNode;

2643 private node;

2644 constructor(startNode: Node, rootNode: Node);

2645 current(): Node | undefined;

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

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

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

2649 private findSibling;

2650 private findPreviousNode;

2651 }

2652 interface Version {

2653 major: number;

2654 minor: number;

2655 }

2656 interface Env {

2657 transparentSrc: string;

2658 documentMode: number;

2659 cacheSuffix: any;

2660 container: any;

2661 canHaveCSP: boolean;

2662 windowsPhone: boolean;

2663 browser: {

2664 current: string | undefined;

2665 version: Version;

2666 isEdge: () => boolean;

2667 isChromium: () => boolean;

2668 isIE: () => boolean;

2669 isOpera: () => boolean;

2670 isFirefox: () => boolean;

2671 isSafari: () => boolean;

2672 };

2673 os: {

2674 current: string | undefined;

2675 version: Version;

2676 isWindows: () => boolean;

2677 isiOS: () => boolean;

2678 isAndroid: () => boolean;

2679 isMacOS: () => boolean;

2680 isLinux: () => boolean;

2681 isSolaris: () => boolean;

2682 isFreeBSD: () => boolean;

2683 isChromeOS: () => boolean;

2684 };

2685 deviceType: {

2686 isiPad: () => boolean;

2687 isiPhone: () => boolean;

2688 isTablet: () => boolean;

2689 isPhone: () => boolean;

2690 isTouch: () => boolean;

2691 isWebView: () => boolean;

2692 isDesktop: () => boolean;

2693 };

2694 }

2695 interface FakeClipboardItem {

2696 readonly items: Record<string, any>;

2697 readonly types: ReadonlyArray<string>;

2698 readonly getType: <D = any>(type: string) => D | undefined;

2699 }

2700 interface FakeClipboard {

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

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

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

2704 readonly clear: () => void;

2705 }

2706 interface FocusManager {

2707 isEditorUIElement: (elm: Element) => boolean;

2708 }

2709 interface EntitiesMap {

2710 [name: string]: string;

2711 }

2712 interface Entities {

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

2714 encodeAllRaw: (text: string) => string;

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

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

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

2718 decode: (text: string) => string;

2719 }

2720 interface IconPack {

2721 icons: Record<string, string>;

2722 }

2723 interface IconManager {

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

2725 get: (id: string) => IconPack;

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

2727 }

2728 interface Resource {

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

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

2731 unload: (id: string) => void;

2732 }

2733 interface Delay {

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

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

2736 }

2737 declare type UploadResult = UploadResult$2;

2738 interface ImageUploader {

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

2740 }

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

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

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

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

2745 interface Tools {

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

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

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

2749 grep: {

2750 <T>(arr: ArrayLike<T> | null | undefined, pred?: ArrayCallback<T, boolean>): T[];

2751 <T>(arr: Record<string, T> | null | undefined, pred?: ObjCallback<T, boolean>): T[];

2752 };

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

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

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

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

2757 each: {

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

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

2760 };

2761 map: {

2762 <T, R>(arr: ArrayLike<T> | null | undefined, cb: ArrayCallback<T, R>): R[];

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

2764 };

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

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

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

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

2769 _addCacheSuffix: (url: string) => string;

2770 }

2771 interface KeyboardLikeEvent {

2772 shiftKey: boolean;

2773 ctrlKey: boolean;

2774 altKey: boolean;

2775 metaKey: boolean;

2776 }

2777 interface VK {

2778 BACKSPACE: number;

2779 DELETE: number;

2780 DOWN: number;

2781 ENTER: number;

2782 ESC: number;

2783 LEFT: number;

2784 RIGHT: number;

2785 SPACEBAR: number;

2786 TAB: number;

2787 UP: number;

2788 PAGE_UP: number;

2789 PAGE_DOWN: number;

2790 END: number;

2791 HOME: number;

2792 modifierPressed: (e: KeyboardLikeEvent) => boolean;

2793 metaKeyPressed: (e: KeyboardLikeEvent) => boolean;

2794 }

2795 interface DOMUtilsNamespace {

2796 (doc: Document, settings: Partial<DOMUtilsSettings>): DOMUtils;

2797 DOM: DOMUtils;

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

2799 }

2800 interface RangeUtilsNamespace {

2801 (dom: DOMUtils): RangeUtils;

2802 compareRanges: (rng1: RangeLikeObject, rng2: RangeLikeObject) => boolean;

2803 getCaretRangeFromPoint: (clientX: number, clientY: number, doc: Document) => Range;

2804 getSelectedNode: (range: Range) => Node;

2805 getNode: (container: Node, offset: number) => Node;

2806 }

2807 interface AddOnManagerNamespace {

2808 <T>(): AddOnManager<T>;

2809 language: string | undefined;

2810 languageLoad: boolean;

2811 baseURL: string;

2812 PluginManager: PluginManager;

2813 ThemeManager: ThemeManager;

2814 ModelManager: ModelManager;

2815 }

2816 interface BookmarkManagerNamespace {

2817 (selection: EditorSelection): BookmarkManager;

2818 isBookmarkNode: (node: Node) => boolean;

2819 }

2820 interface TinyMCE extends EditorManager {

2821 geom: {

2822 Rect: Rect;

2823 };

2824 util: {

2825 Delay: Delay;

2826 Tools: Tools;

2827 VK: VK;

2828 URI: URIConstructor;

2829 EventDispatcher: EventDispatcherConstructor<any>;

2830 Observable: Observable<any>;

2831 I18n: I18n;

2832 LocalStorage: Storage;

2833 ImageUploader: ImageUploader;

2834 };

2835 dom: {

2836 EventUtils: EventUtilsConstructor;

2837 TreeWalker: DomTreeWalkerConstructor;

2838 TextSeeker: (dom: DOMUtils, isBlockBoundary?: (node: Node) => boolean) => TextSeeker;

2839 DOMUtils: DOMUtilsNamespace;

2840 ScriptLoader: ScriptLoaderConstructor;

2841 RangeUtils: RangeUtilsNamespace;

2842 Serializer: (settings: DomSerializerSettings, editor?: Editor) => DomSerializer;

2843 ControlSelection: (selection: EditorSelection, editor: Editor) => ControlSelection;

2844 BookmarkManager: BookmarkManagerNamespace;

2845 Selection: (dom: DOMUtils, win: Window, serializer: DomSerializer, editor: Editor) => EditorSelection;

2846 StyleSheetLoader: (documentOrShadowRoot: Document | ShadowRoot, settings: StyleSheetLoaderSettings) => StyleSheetLoader;

2847 Event: EventUtils;

2848 };

2849 html: {

2850 Styles: (settings?: StylesSettings, schema?: Schema) => Styles;

2851 Entities: Entities;

2852 Node: AstNodeConstructor;

2853 Schema: (settings?: SchemaSettings) => Schema;

2854 DomParser: (settings?: DomParserSettings, schema?: Schema) => DomParser;

2855 Writer: (settings?: WriterSettings) => Writer;

2856 Serializer: (settings?: HtmlSerializerSettings, schema?: Schema) => HtmlSerializer;

2857 };

2858 AddOnManager: AddOnManagerNamespace;

2859 Annotator: (editor: Editor) => Annotator;

2860 Editor: EditorConstructor;

2861 EditorCommands: EditorCommandsConstructor;

2862 EditorManager: EditorManager;

2863 EditorObservable: EditorObservable;

2864 Env: Env;

2865 FocusManager: FocusManager;

2866 Formatter: (editor: Editor) => Formatter;

2867 NotificationManager: (editor: Editor) => NotificationManager;

2868 Shortcuts: ShortcutsConstructor;

2869 UndoManager: (editor: Editor) => UndoManager;

2870 WindowManager: (editor: Editor) => WindowManager;

2871 DOM: DOMUtils;

2872 ScriptLoader: ScriptLoader;

2873 PluginManager: PluginManager;

2874 ThemeManager: ThemeManager;

2875 ModelManager: ModelManager;

2876 IconManager: IconManager;

2877 Resource: Resource;

2878 FakeClipboard: FakeClipboard;

2879 trim: Tools['trim'];

2880 isArray: Tools['isArray'];

2881 is: Tools['is'];

2882 toArray: Tools['toArray'];

2883 makeMap: Tools['makeMap'];

2884 each: Tools['each'];

2885 map: Tools['map'];

2886 grep: Tools['grep'];

2887 inArray: Tools['inArray'];

2888 extend: Tools['extend'];

2889 walk: Tools['walk'];

2890 resolve: Tools['resolve'];

2891 explode: Tools['explode'];

2892 _addCacheSuffix: Tools['_addCacheSuffix'];

2893 }

2894 declare const tinymce: TinyMCE;

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