@acrolinx/sidebar-sdk 1.1.13 → 2.0.0-dev1

package/dist/index.d.ts

@@ -1,23 +1,612 @@
-export { AcrolinxPlugin, autoBindFloatingSidebar } from './acrolinx-plugin';
-export { AdapterInterface, AsyncAdapterInterface, CommonAdapterInterface } from './adapters/AdapterInterface';
-export { InputAdapter } from './adapters/InputAdapter';
-export { ContentEditableAdapter } from './adapters/ContentEditableAdapter';
-export { AsyncContentEditableAdapter as StateBasedContentEditableAdapter } from './adapters/AsyncContentEditableAdapter';
-export { AbstractRichtextEditorAdapter } from './adapters/AbstractRichtextEditorAdapter';
-export { CKEditorAdapter } from './adapters/CKEditorAdapter';
-export { CKEditor5Adapter } from './adapters/CKEditor5Adapter';
-export { TinyMCEAdapter } from './adapters/TinyMCEAdapter';
-export { TinyMCEWordpressAdapter } from './adapters/TinyMCEWordpressAdapter';
-export { AutoBindAdapter } from './adapters/AutoBindAdapter';
-export { AsyncAutoBindAdapter } from './adapters/AsyncAutoBindAdapter';
-export { MultiEditorAdapter } from './adapters/MultiEditorAdapter';
-export { AsyncMultiEditorAdapter } from './adapters/AsyncMultiEditorAdapter';
-export { createPluginMessageAdapter } from './message-adapter/message-adapter';
-export { loadSidebarCode } from './utils/sidebar-loader';
-export { getSelectionHtmlRanges } from './utils/check-selection';
-export { lookupMatches } from './lookup/diff-based';
-export { extractTextDomMapping } from './utils/text-dom-mapping';
-export { CodeMirrorAdapter } from './adapters/CodeMirrorAdapter';
-export { CodeMirror6Adapter } from './adapters/CodeMirror6Adapter';
-export { initFloatingSidebar } from './floating-sidebar/floating-sidebar';
-export { AsyncLocalStorage } from './floating-sidebar/async-storage';
+import { AcrolinxPlugin as AcrolinxPlugin_2 } from '@acrolinx/sidebar-interface';
+import { AcrolinxStorage } from '@acrolinx/sidebar-interface';
+import { Check } from '@acrolinx/sidebar-interface';
+import { CheckedDocumentPart } from '@acrolinx/sidebar-interface';
+import { CheckInformationKeyValuePair } from '@acrolinx/sidebar-interface';
+import { CheckResult } from '@acrolinx/sidebar-interface';
+import { default as default_2 } from '@ckeditor/ckeditor5-build-inline';
+import { DocumentSelection } from '@acrolinx/sidebar-interface';
+import { Editor } from 'tinymce';
+import { EditorView } from '@codemirror/view';
+import { ExternalContent } from '@acrolinx/sidebar-interface';
+import { InitParameters } from '@acrolinx/sidebar-interface';
+import { InitResult } from '@acrolinx/sidebar-interface';
+import { LogEntry } from '@acrolinx/sidebar-interface';
+import { Match } from '@acrolinx/sidebar-interface';
+import { MatchWithReplacement } from '@acrolinx/sidebar-interface';
+import { Message } from '@acrolinx/sidebar-interface';
+import { SidebarConfiguration } from '@acrolinx/sidebar-interface';
+
+export declare abstract class AbstractRichtextEditorAdapter implements AdapterInterface {
+    config: AdapterConf;
+    currentContentChecking?: string;
+    lastContentChecked?: string;
+    protected constructor(conf: AdapterConf);
+    abstract getEditorDocument(): Document;
+    abstract getContent(opts: ExtractContentForCheckOpts): string;
+    protected getEditorElement(): HTMLElement;
+    registerCheckCall(_checkInfo: Check): void;
+    registerCheckResult(_checkResult: SuccessfulCheckResult): void;
+    extractContentForCheck(opts: ExtractContentForCheckOpts): ContentExtractionResult | Promise<ContentExtractionResult>;
+    protected getSelection(): DocumentSelection;
+    protected scrollIntoView(sel: Selection): void | Promise<void>;
+    scrollToCurrentSelection(): void;
+    protected scrollElementIntoView(el: HTMLElement): void;
+    selectRanges(checkId: string, matches: Match[]): void;
+    protected isCkEditor5(): boolean;
+    protected isQuillEditor(): boolean;
+    protected selectMatches<T extends Match>(_checkId: string, matches: T[]): [AlignedMatch<T>[], TextMapping];
+    protected selectAlignedMatches(matches: AlignedMatch<Match>[], textMapping: TextMapping): void;
+    protected selectText(begin: number, length: number, textMapping: TextMapping): void;
+    protected createRange(begin: number, length: number, textMapping: TextMapping): Range;
+    protected replaceAlignedMatches(matches: AlignedMatch<MatchWithReplacement>[]): void;
+    replaceRanges(checkId: string, matchesWithReplacement: MatchWithReplacement[]): void;
+    protected getTextDomMapping(): TextDomMapping;
+    getAutobindWrapperAttributes(): AutobindWrapperAttributes;
+}
+
+export declare class AcrolinxPlugin {
+    private readonly initConfig;
+    private adapter?;
+    private config;
+    private internalPlugin?;
+    constructor(conf: AcrolinxPluginConfig);
+    registerAdapter(adapter: AdapterInterface): void;
+    configure(conf: SidebarConfiguration): void;
+    check(): void;
+    /**
+     * Show a message in the Sidebar.
+     * Supported since Acrolinx Platform 2021.2 (Sidebar version 14.28).
+     * @param message The message to show.
+     */
+    showMessage(message: Message): void;
+    init(): Promise<void>;
+    dispose(callback: () => void): void;
+}
+
+export declare interface AcrolinxPluginConfig extends InitParameters {
+    sidebarContainerId: string;
+    sidebarUrl?: string;
+    sidebarHtml?: string;
+    checkSelection?: boolean;
+    useMessageAdapter?: boolean;
+    useSidebarFromSameOriginDirectly?: boolean;
+    onSidebarWindowLoaded?: (sidebarWindow: Window) => void;
+    getDocumentReference?: () => string;
+    acrolinxStorage?: AcrolinxStorage;
+    onEmbedCheckData?: (checkData: CheckInformationKeyValuePair[], format: string) => void;
+    onInitFinished?: (initFinishedResult: InitResult) => void;
+    onCheckResult?: (checkResult: CheckResult) => void;
+    openLogFile?: () => void;
+    openWindow?: (url: string) => void;
+    log?: (logEntry: LogEntry) => void;
+}
+
+export declare interface AcrolinxSidebarIntegration {
+    AcrolinxPlugin: typeof AcrolinxPlugin;
+    autoBindFloatingSidebar: typeof autoBindFloatingSidebar;
+    autoBindFloatingSidebarAsync: typeof autoBindFloatingSidebarAsync;
+    initFloatingSidebar: typeof initFloatingSidebar;
+    AsyncLocalStorage: typeof AsyncLocalStorage;
+    createPluginMessageAdapter: typeof createPluginMessageAdapter;
+    loadSidebarCode: typeof loadSidebarCode;
+    getSelectionHtmlRanges: typeof getSelectionHtmlRanges;
+    adapter: {
+        AbstractRichtextEditorAdapter: typeof AbstractRichtextEditorAdapter;
+        AutoBindAdapter: typeof AutoBindAdapter;
+        AsyncAutoBindAdapter: typeof AsyncAutoBindAdapter;
+        CKEditor5Adapter: typeof CKEditor5Adapter;
+        CodeMirror6Adapter: typeof CodeMirror6Adapter;
+        ContentEditableAdapter: typeof ContentEditableAdapter;
+        AsyncContentEditableAdapter: typeof StateBasedContentEditableAdapter;
+        InputAdapter: typeof InputAdapter;
+        MultiEditorAdapter: typeof MultiEditorAdapter;
+        AsyncMultiEditorAdapter: typeof AsyncMultiEditorAdapter;
+        TinyMCEAdapter: typeof TinyMCEAdapter;
+        XeditorAdapter: typeof XeditorAdapter;
+    };
+    lookup: {
+        lookupMatches: typeof lookupMatches;
+    };
+    extractTextDomMapping: typeof extractTextDomMapping;
+}
+
+declare type AdapterConf = HasEditorID | HasElement;
+
+export declare interface AdapterInterface extends CommonAdapterInterface {
+    selectRanges(checkId: string, matches: Match[]): void;
+    replaceRanges(checkId: string, matchesWithReplacement: MatchWithReplacement[]): void;
+}
+
+declare type AddSingleAdapterOptions = WrapperConfOptions;
+
+declare interface AlignedMatch<T extends Match> {
+    originalMatch: T;
+    range: [number, number];
+}
+
+export declare interface AsyncAdapterInterface extends CommonAdapterInterface {
+    readonly isAsync: true;
+    readonly requiresSynchronization: boolean;
+    selectRanges(checkId: string, matches: Match[]): Promise<void>;
+    replaceRanges(checkId: string, matchesWithReplacement: MatchWithReplacement[]): Promise<void>;
+}
+
+export declare class AsyncAutoBindAdapter implements AsyncAdapterInterface {
+    private conf;
+    readonly isAsync: true;
+    readonly requiresSynchronization: true;
+    private asyncMultiAdapter;
+    constructor(conf: MultiEditorAdapterConfig & CommonAdapterConf & AutobindConfig);
+    private initMultiAdapter;
+    getFormat(): "HTML" | "AUTO";
+    extractContentForCheck(opts: ExtractContentForCheckOpts): Promise<ContentExtractionResult>;
+    registerCheckCall(_checkInfo: Check): void;
+    registerCheckResult(_checkResult: SuccessfulCheckResult): void;
+    selectRanges(checkId: string, matches: Match[]): Promise<void>;
+    replaceRanges(checkId: string, matchesWithReplacement: MatchWithReplacement[]): Promise<void>;
+}
+
+export declare class AsyncLocalStorage implements AsyncStorage {
+    get<T>(key: string): Promise<T | null>;
+    set<T>(key: string, value: T): Promise<undefined>;
+}
+
+export declare class AsyncMultiEditorAdapter extends MultiEditorAdapter implements AsyncAdapterInterface {
+    readonly isAsync: true;
+    readonly requiresSynchronization: true;
+    addSingleAdapter(singleAdapter: AsyncAdapterInterface | AdapterInterface, opts?: AddSingleAdapterOptions, id?: string): void;
+    selectRanges(checkId: string, matches: Match[]): Promise<void>;
+    replaceRanges(checkId: string, matchesWithReplacement: MatchWithReplacement[]): Promise<void>;
+}
+
+declare interface AsyncStorage {
+    get<T>(key: string): Promise<T | null>;
+    set<T>(key: string, value: T): Promise<void>;
+}
+
+declare type AttributeMap = {
+    [key: string]: any;
+};
+
+export declare class AutoBindAdapter implements AdapterInterface {
+    private conf;
+    private multiAdapter;
+    constructor(conf: MultiEditorAdapterConfig & CommonAdapterConf & AutobindConfig);
+    private initMultiAdapter;
+    getFormat(): "HTML" | "AUTO";
+    extractContentForCheck(opts: ExtractContentForCheckOpts): Promise<ContentExtractionResult>;
+    registerCheckCall(_checkInfo: Check): void;
+    registerCheckResult(_checkResult: SuccessfulCheckResult): void;
+    selectRanges(checkId: string, matches: Match[]): void;
+    replaceRanges(checkId: string, matchesWithReplacement: MatchWithReplacement[]): void;
+}
+
+declare interface AutobindConfig extends CommonAdapterConf {
+    enableQuipAdapter?: boolean;
+}
+
+export declare function autoBindFloatingSidebar(basicConf: AutoBindFloatingSidebarConfig): Promise<FloatingSidebar>;
+
+export declare function autoBindFloatingSidebarAsync(basicConf: AutoBindFloatingSidebarConfig): Promise<FloatingSidebar>;
+
+declare interface AutoBindFloatingSidebarConfig extends AcrolinxPluginConfig, MultiEditorAdapterConfig, AutobindConfig {
+    asyncStorage?: AsyncStorage;
+}
+
+declare interface AutobindWrapperAttributes {
+    'original-id'?: string;
+    'original-class'?: string;
+    'original-name'?: string;
+    'original-source': string;
+    'original-display'?: string;
+    [key: string]: string | undefined;
+}
+
+declare interface CheckContentResult {
+    dom: HTMLElement;
+    text: string;
+    html: string;
+}
+
+declare interface CheckedRegisteredAdapter extends RegisteredAdapter {
+    checkedRange: [number, number];
+}
+
+export declare class CKEditor5Adapter extends AbstractRichtextEditorAdapter {
+    editorId: string;
+    constructor(conf: HasEditorID);
+    getEditor(): default_2;
+    getEditorDocument(): Document;
+    getContent(): string;
+    extractContentForCheck(): ContentExtractionResult;
+    selectRanges(checkId: string, matches: Match[]): void;
+    getEditorElement(): HTMLElement;
+    replaceRanges(checkId: string, matchesWithReplacementArg: MatchWithReplacement[]): void;
+    isInSourceEditingMode(): boolean;
+}
+
+export declare class CodeMirror6Adapter implements AdapterInterface {
+    private config;
+    private currentContentChecking?;
+    private lastContentChecked?;
+    private formatDetectedByCheck;
+    constructor(conf: CodeMirror6AdapterConf);
+    configure(partialConfig: Partial<CodeMirror6AdapterConf>): void;
+    private validateConf;
+    getContent(): string;
+    getFormat(): string;
+    extractContentForCheck(opts: ExtractContentForCheckOpts): ContentExtractionResult;
+    private getSelection;
+    registerCheckResult(checkResult: SuccessfulCheckResult): void;
+    registerCheckCall(_checkInfo: Check): void;
+    private lookupMatchesOrThrow;
+    selectRanges(_checkId: string, matches: Match[]): void;
+    replaceRanges(_checkId: string, matchesWithReplacement: MatchWithReplacement[]): void;
+    private getEscapeFunction;
+    private selectRange;
+    private selectRangeAndScroll;
+    private cmSelectionToRange;
+}
+
+declare type CodeMirror6AdapterConf = {
+    editor: EditorView;
+    format?: string;
+};
+
+declare interface CommonAdapterConf {
+    scrollOffsetY?: number;
+    disableInputEventSimulation?: boolean;
+}
+
+export declare interface CommonAdapterInterface {
+    getFormat?(): string;
+    getContent?(opts: ExtractContentForCheckOpts): string;
+    extractContentForCheck(opts: ExtractContentForCheckOpts): ContentExtractionResult | Promise<ContentExtractionResult>;
+    registerCheckCall(checkInfo: Check): void;
+    registerCheckResult(checkResult: SuccessfulCheckResult): void;
+    getAutobindWrapperAttributes?(): AutobindWrapperAttributes;
+    onInitFinished?(result: InitResult): void;
+}
+
+export declare class ContentEditableAdapter extends AbstractRichtextEditorAdapter {
+    element: HTMLElement;
+    constructor(conf: AdapterConf);
+    getEditorElement(): HTMLElement;
+    getContent(): string;
+    protected getSelection(): DocumentSelection;
+    getEditorDocument(): Document;
+}
+
+declare type ContentExtractionResult = SuccessfulContentExtractionResult | HasError;
+
+/**
+ * Used inside of a sidebar iframe on a different domain.
+ */
+export declare function createPluginMessageAdapter(win?: Window & typeof globalThis): AcrolinxPlugin_2;
+
+declare interface DomPosition {
+    node: Node;
+    offset: number;
+}
+
+declare type ElementHtmlGetter = (el: HTMLElement) => string;
+
+declare interface EscapeHtmlCharactersResult {
+    escapedText: string;
+    backwardAlignment: OffSetAlign[];
+}
+
+declare interface ExtractContentForCheckOpts {
+    checkSelection?: boolean;
+}
+
+export declare function extractTextDomMapping(node: Node): TextDomMapping;
+
+declare interface FloatingSidebar {
+    toggleVisibility(): void;
+    remove(): void;
+}
+
+declare interface FloatingSidebarConfig {
+    asyncStorage: AsyncStorage;
+    sidebarContainerId?: string;
+}
+
+declare type Format = 'TEXT' | 'MARKDOWN';
+
+export declare function getSelectionHtmlRanges(editorElement: HTMLElement, getElementHtml?: ElementHtmlGetter): [number, number][];
+
+declare interface HasEditorID extends CommonAdapterConf {
+    editorId: string;
+}
+
+declare interface HasElement extends CommonAdapterConf {
+    element: HTMLElement;
+}
+
+declare interface HasError {
+    error: any;
+}
+
+export declare function initFloatingSidebar(config: FloatingSidebarConfig): FloatingSidebar;
+
+export declare class InputAdapter implements AdapterInterface {
+    readonly element: ValidInputElement;
+    config: InputAdapterConf;
+    private currentContentChecking?;
+    private lastContentChecked?;
+    constructor(conf: InputAdapterConf);
+    getContent(): string;
+    getCurrentText(): string;
+    getFormat(): Format;
+    extractContentForCheck(opts: ExtractContentForCheckOpts): ContentExtractionResult;
+    private getSelection;
+    registerCheckResult(_checkResult: SuccessfulCheckResult): void;
+    registerCheckCall(_checkInfo: Check): void;
+    scrollAndSelect(matches: AlignedMatch<Match>[]): void;
+    selectRanges(checkId: string, matches: Match[]): void;
+    selectMatches<T extends Match>(_checkId: string, matches: T[]): AlignedMatch<T>[];
+    replaceAlignedMatches(matches: AlignedMatch<MatchWithReplacement>[]): void;
+    replaceRanges(checkId: string, matchesWithReplacement: MatchWithReplacement[]): void;
+    getAutobindWrapperAttributes(): AutobindWrapperAttributes;
+}
+
+declare type InputAdapterConf = AdapterConf & {
+    format?: Format;
+};
+
+declare type InputFormat = 'HTML' | 'TEXT';
+
+/**
+ * Loads the Styles and Scripts of the sidebar into the current window.
+ * @param sidebarUrl must end with /
+ *
+ * TODO: Is this function currently used in any of our clients?
+ */
+export declare function loadSidebarCode(sidebarBaseUrl: string): Promise<void>;
+
+/**
+ * @param {string} checkedDocument Text or HTML of the document (at check time)
+ * @param {string} currentDocument Text or HTML of the current document
+ *
+ * @param {T[]} matches
+ *
+ * @param {InputFormat} inputFormat
+ * If checkedDocument is the HTML of the document (at check time)
+ * and currentDocument is the extracted text of the current document then
+ * you should set inputFormat to 'HTML'.
+ *
+ * @return {AlignedMatch<T extends Match>[]}
+ */
+export declare function lookupMatches<T extends Match>(checkedDocument: string, currentDocument: string, matches: T[], inputFormat?: InputFormat): AlignedMatch<T>[];
+
+export declare class MultiEditorAdapter implements AdapterInterface {
+    private config;
+    private rootElementWrapper?;
+    private adapters;
+    private adaptersOfLastSuccessfulCheck?;
+    constructor(config?: MultiEditorAdapterConfig);
+    getFormat(): "HTML" | "AUTO";
+    protected addSingleAdapterInternal(singleAdapter: AdapterInterface | AsyncAdapterInterface, opts?: AddSingleAdapterOptions, id?: string): void;
+    addSingleAdapter(singleAdapter: AdapterInterface, opts?: AddSingleAdapterOptions, id?: string): void;
+    removeAllAdapters(): void;
+    extractContentForCheck(opts: ExtractContentForCheckOpts): Promise<ContentExtractionResult>;
+    registerCheckCall(_checkInfo: Check): void;
+    registerCheckResult(checkResult: SuccessfulCheckResult): void;
+    selectRanges(checkId: string, matches: Match[]): void;
+    remapMatches<T extends Match>(matches: T[]): {
+        [id: string]: RemappedMatches<T>;
+    };
+    getAdapterForMatch(match: Match): CheckedRegisteredAdapter;
+    replaceRanges(checkId: string, matchesWithReplacement: MatchWithReplacement[]): void;
+}
+
+declare interface MultiEditorAdapterConfig {
+    aggregateFormat?: 'AUTO' | 'HTML';
+    documentHeader?: string;
+    rootElement?: WrapperConfOptions;
+    beforeCheck?: (multiAdapter: MultiEditorAdapter) => void;
+}
+
+declare interface OffSetAlign {
+    oldPosition: number;
+    diffOffset: number;
+}
+
+declare interface RegisteredAdapter {
+    id: string;
+    adapter: AdapterInterface | AsyncAdapterInterface;
+    wrapper: WrapperConf;
+    checkedRange?: [number, number];
+    escapeResult?: EscapeHtmlCharactersResult;
+}
+
+declare interface RemappedMatches<T extends Match> {
+    matches: T[];
+    adapter: AdapterInterface;
+}
+
+export declare class StateBasedContentEditableAdapter extends AbstractRichtextEditorAdapter implements AsyncAdapterInterface {
+    element: HTMLElement;
+    constructor(conf: AdapterConf);
+    readonly isAsync: true;
+    readonly requiresSynchronization: true;
+    getEditorElement(): HTMLElement;
+    getContent(): string;
+    protected getSelection(): DocumentSelection;
+    getEditorDocument(): Document;
+    selectRanges(checkId: string, matches: Match[]): Promise<void>;
+    replaceRanges(checkId: string, matchesWithReplacement: MatchWithReplacement[]): Promise<void>;
+    selectText(begin: number, length: number, textMapping: TextMapping_2): Promise<void>;
+    private addSelectionRange;
+    scrollIntoView(sel: Selection): Promise<void>;
+}
+
+declare interface SuccessfulCheckResult {
+    checkedPart: CheckedDocumentPart;
+    embedCheckInformation?: CheckInformationKeyValuePair[];
+    inputFormat?: string;
+}
+
+declare interface SuccessfulContentExtractionResult {
+    content: string;
+    documentReference?: string;
+    selection?: DocumentSelection;
+    externalContent?: ExternalContent;
+}
+
+declare interface TextDomMapping {
+    text: string;
+    domPositions: DomPosition[];
+}
+
+declare type TextMapping = TextDomMapping;
+
+declare type TextMapping_2 = TextDomMapping;
+
+export declare class TinyMCEAdapter extends AbstractRichtextEditorAdapter {
+    editorId: string;
+    constructor(conf: HasEditorID);
+    getEditor(): Editor;
+    getContent(opts: ExtractContentForCheckOpts): string;
+    getContentForCheckSelection: (el: HTMLElement) => string;
+    protected getSelection(): DocumentSelection;
+    getEditorDocument(): Document;
+}
+
+declare type ValidInputElement = HTMLInputElement | HTMLTextAreaElement;
+
+declare interface WrapperConf extends WrapperConfOptions {
+    tagName: string;
+    attributes: AttributeMap;
+}
+
+declare interface WrapperConfOptions {
+    tagName?: string;
+    attributes?: AttributeMap;
+}
+
+export declare class XeditorAdapter implements AdapterInterface {
+    /**
+     * Editor of this adapter
+     *
+     * @property {any} editor
+     * Native Xeditor editor instance
+     */
+    protected editor: any;
+    /**
+     * Document of this adapter
+     *
+     * @property {any} editor
+     * Native Xeditor document instance
+     */
+    protected document: any;
+    /**
+     * SelectionManager of this adapter
+     *
+     * @property {any} editor
+     * Native Xeditor selection manager instance
+     */
+    protected selectionManager: any;
+    /**
+     * Content that is currently checking
+     *
+     * @property {string} currentContentChecking
+     * Content that is currently checking
+     */
+    protected currentContentChecking: string;
+    /**
+     * Content that was last checked
+     *
+     * @property {string} lastContentChecked
+     * Content that was last checked
+     */
+    protected lastContentChecked: string;
+    /**
+     * Creates a new instance of this acrolinx adapter
+     */
+    constructor(editor: any);
+    /**
+     * Implementation of getFormat of acrolinx.AdapterInterface
+     *
+     * @returns {string} Returns 'HTML'
+     */
+    getFormat(): string;
+    /**
+     * @inheritdoc
+     */
+    extractContentForCheck(_opts: ExtractContentForCheckOpts): ContentExtractionResult | Promise<ContentExtractionResult>;
+    /**
+     * @inheritdoc
+     */
+    registerCheckCall(_checkInfo: Check): void;
+    /**
+     * @inheritdoc
+     */
+    registerCheckResult(_checkResult: SuccessfulCheckResult): void;
+    /**
+     * @inheritdoc
+     */
+    replaceRanges(_checkId: string, matchesWithReplacement: MatchWithReplacement[]): void;
+    /**
+     * @inheritdoc
+     */
+    selectRanges(_checkId: string, matches: Match[]): void;
+    /**
+     * Replaces the aligned matches.
+     *
+     * @param {AlignedMatch<MatchWithReplacement>[]} matches
+     *             Matches to replace
+     * @protected
+     */
+    replaceAlignedMatches(matches: AlignedMatch<MatchWithReplacement>[]): void;
+    /**
+     * Selects the given `matches` by aligning them and calling `selectAlignedMatches`.
+     *
+     * @param {Match[]} matches
+     *             Matches to select
+     * @returns {AlignedMatch<T>[]} Aligned matches
+     * @protected
+     */
+    selectMatches<T extends Match>(matches: Match[]): AlignedMatch<T>[];
+    /**
+     * Selects the given `matches` using `selectText`.
+     *
+     * @param {AlignedMatch<Match>[]} matches
+     *             Aligned matches to select
+     * @protected
+     */
+    selectAlignedMatches(matches: AlignedMatch<Match>[]): void;
+    /**
+     * Selects the range for the given offset.
+     *
+     * @param {number} begin
+     *             Begin of the range
+     * @param {number} end
+     *             End of the range
+     * @protected
+     */
+    selectText(begin: number, end: number): void;
+    /**
+     * Returns the prepared content for a check.
+     *
+     * @returns {CheckContentResult} Content to check
+     * @protected
+     */
+    getContentForCheck(): CheckContentResult;
+    /**
+     * Returns the specific element that should be used for the acrolinx check.
+     *
+     * @param {any} _element
+     * Element to get the acrolinx element from
+     * @param {any} role
+     * Role of the passed `_element`
+     * @param currentElement
+     * Element which is currently used
+     * @returns {HTMLElement} Element that should be used for acrolinx check
+     */
+    getAcrolinxElement(_element: any, role: any, currentElement: any): HTMLElement;
+}
+
+export { }