quill

constructor(container: string | HTMLElement, options?: QuillOptions);

protected allowReadOnlyEdits: boolean;

clipboard: Clipboard;

composition: Composition;

container: HTMLElement;

static DEFAULTS: {
    bounds: null;
    modules: {
        clipboard: boolean;
        keyboard: boolean;
        history: boolean;
        uploader: boolean;
    };
    placeholder: string;
    readOnly: false;
    registry: Parchment.Registry;
    theme: string;
};

editor: Editor;

emitter: Emitter;

static events: {
    readonly EDITOR_CHANGE: 'editor-change';
    readonly SCROLL_BEFORE_UPDATE: 'scroll-before-update';
    readonly SCROLL_BLOT_MOUNT: 'scroll-blot-mount';
    readonly SCROLL_BLOT_UNMOUNT: 'scroll-blot-unmount';
    readonly SCROLL_OPTIMIZE: 'scroll-optimize';
    readonly SCROLL_UPDATE: 'scroll-update';
    readonly SCROLL_EMBED_UPDATE: 'scroll-embed-update';
    readonly SELECTION_CHANGE: 'selection-change';
    readonly TEXT_CHANGE: 'text-change';
    readonly COMPOSITION_BEFORE_START: 'composition-before-start';
    readonly COMPOSITION_START: 'composition-start';
    readonly COMPOSITION_BEFORE_END: 'composition-before-end';
    readonly COMPOSITION_END: 'composition-end';
};

history: History;

static imports: Record<string, unknown>;

keyboard: Keyboard;

options: ExpandedQuillOptions;

root: HTMLDivElement;

scroll: Scroll;

selection: Selection;

static sources: {
    readonly API: 'api';
    readonly SILENT: 'silent';
    readonly USER: 'user';
};

theme: Theme;

uploader: Uploader;

static version: string;

addContainer: {
    (container: string, refNode?: Node | null): HTMLDivElement;
    (container: HTMLElement, refNode?: Node): HTMLElement;
};

blur: () => void;

static debug: (limit: DebugLevel | boolean) => void;

deleteText: {
    (range: Range, source?: EmitterSource): Delta;
    (index: number, length: number, source?: EmitterSource): Delta;
};

disable: () => void;

editReadOnly: <T>(modifier: () => T) => T;

enable: (enabled?: boolean) => void;

static find: (node: Node, bubble?: boolean) => Parchment.Blot | Quill | null;

focus: (options?: { preventScroll?: boolean }) => void;

format: (name: string, value: unknown, source?: EmitterSource) => any;

formatLine: {
    (
        index: number,
        length: number,
        formats: Record<string, unknown>,
        source?: EmitterSource
    ): Delta;
    (
        index: number,
        length: number,
        name: string,
        value?: unknown,
        source?: EmitterSource
    ): Delta;
};

formatText: {
    (range: Range, name: string, value: unknown, source?: EmitterSource): Delta;
    (
        index: number,
        length: number,
        name: string,
        value: unknown,
        source?: EmitterSource
    ): Delta;
    (
        index: number,
        length: number,
        formats: Record<string, unknown>,
        source?: EmitterSource
    ): Delta;
};

getBounds: (index: number | Range, length?: number) => Bounds | null;

getContents: (index?: number, length?: number) => Delta;

getFormat: {
    (index?: number, length?: number): { [format: string]: unknown };
    (range?: Range): { [format: string]: unknown };
};

getIndex: (blot: Parchment.Blot) => number;

getLeaf: (index: number) => [Parchment.LeafBlot | null, number];

getLength: () => number;

getLine: (index: number) => [Block | BlockEmbed | null, number];

getLines: {
    (range: Range): (Block | BlockEmbed)[];
    (index?: number, length?: number): (Block | BlockEmbed)[];
};

getModule: (name: string) => unknown;

getSelection: { (focus: true): Range; (focus?: boolean): Range };

getSemanticHTML: {
    (range: Range): string;
    (index?: number, length?: number): string;
};

getText: { (range?: Range): string; (index?: number, length?: number): string };

hasFocus: () => boolean;

static import: {
    (name: 'core/module'): typeof Module;
    (name: `themes/${string}`): typeof Theme;
    (name: 'parchment'): any;
    (name: 'delta'): any;
    (name: string): unknown;
};

insertEmbed: (
    index: number,
    embed: string,
    value: unknown,
    source?: EmitterSource
) => any;

insertText: {
    (index: number, text: string, source?: EmitterSource): Delta;
    (
        index: number,
        text: string,
        formats: Record<string, unknown>,
        source?: EmitterSource
    ): Delta;
    (
        index: number,
        text: string,
        name: string,
        value: unknown,
        source?: EmitterSource
    ): Delta;
};

isEnabled: () => boolean;

off: (...args: Parameters<(typeof Emitter)['prototype']['off']>) => Emitter;

on: {
    (
        event: (typeof Emitter)['events']['TEXT_CHANGE'],
        handler: (delta: Delta, oldContent: Delta, source: EmitterSource) => void
    ): Emitter;
    (
        event: 'selection-change',
        handler: (range: Range, oldRange: Range, source: EmitterSource) => void
    ): Emitter;
    (
        event: 'editor-change',
        handler: (
            ...args:
                | ['text-change', Delta, Delta, EmitterSource]
                | ['selection-change', Range, Range, EmitterSource]
        ) => void
    ): Emitter;
    (event: string, ...args: unknown[]): Emitter;
};

once: (...args: Parameters<(typeof Emitter)['prototype']['once']>) => Emitter;

static register: (
    path:
        | string
        | Parchment.BlotConstructor
        | Parchment.Attributor
        | Record<string, unknown>,
    target?: Parchment.BlotConstructor | Parchment.Attributor | boolean,
    overwrite?: boolean
) => void;

removeFormat: (index: number, length: number, source?: EmitterSource) => any;

scrollIntoView: () => void;

scrollRectIntoView: (rect: Rect) => void;

scrollSelectionIntoView: () => void;

setContents: (delta: Delta | Op[], source?: EmitterSource) => any;

setSelection: {
    (range: Range | null, source?: EmitterSource): void;
    (index: number, source?: EmitterSource): void;
    (index: number, length?: number, source?: EmitterSource): void;
    (index: number, source?: EmitterSource): void;
};

setText: (text: string, source?: EmitterSource) => any;

update: (source?: EmitterSource) => void;

updateContents: (delta: Delta | Op[], source?: EmitterSource) => any;

constructor(index: number, length?: number);

index: number;

length: number;

bottom: number;

height: number;

left: number;

right: number;

top: number;

width: number;

bounds?: HTMLElement | null;

container: HTMLElement;

modules: Record<string, unknown>;

readOnly: boolean;

registry: Parchment.Registry;

theme: ThemeConstructor;

bounds?: HTMLElement | string | null;

debug?: DebugLevel | boolean;

formats?: string[] | null;

modules?: Record<string, unknown>;

placeholder?: string;

readOnly?: boolean;

registry?: Parchment.Registry;

theme?: string;