WebSVN – oidplus – Blame – /trunk/vendor/tinymce/tinymce/tinymce.d.ts

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

Subversion Repositories oidplus

oidplus/trunk/vendor/tinymce/tinymce/tinymce.d.ts – Rev 679