@modusoperandi/licit-import-utils 0.1.0

package/licit-elements.d.ts

@@ -0,0 +1,878 @@
+/**
+ * @license MIT
+ * @copyright Copyright 2026 Modus Operandi Inc. All Rights Reserved.
+ */
+interface InfoIconData {
+    infoIconClass: string;
+    infoIconUnicode: string;
+}
+type LicitAttrs = Record<string, unknown>;
+interface Mark {
+    type: string;
+    attrs?: LicitAttrs;
+    marks?: {
+        type: string;
+        attrs?: LicitAttrs;
+    }[];
+    text?: string;
+}
+export type LicitElementJSON = Record<string, unknown>;
+interface LicitElementAttrsJSON extends LicitAttrs {
+    parser?: LicitAttrs;
+}
+interface LicitMarksJSON {
+    type: string;
+    attrs?: LicitAttrs;
+}
+interface LicitDocumentAttrsJSON extends LicitElementAttrsJSON {
+    layout: null;
+    padding: null;
+    width: null;
+}
+export interface LicitImageAttrsJSON extends LicitElementAttrsJSON {
+    align: string | null;
+    alt: string | null;
+    crop: string | null;
+    height: string | null;
+    rotate: string | null;
+    src: string | null;
+    title: string | null;
+    width: string | null;
+    fitToParent: number;
+}
+interface LicitImageJSON extends LicitElementJSON {
+    type: string;
+    attrs: LicitImageAttrsJSON;
+}
+interface LicitParagraphImageAttrsJSON extends LicitElementAttrsJSON {
+    styleName?: string;
+}
+interface LicitImageContentJSON extends LicitElementJSON {
+    type: string;
+    attrs: LicitImageAttrsJSON;
+}
+interface LicitParagraphImageJSON extends LicitElementJSON {
+    type: string;
+    attrs: LicitParagraphImageAttrsJSON;
+    content: LicitImageContentJSON[];
+}
+interface LicitHeaderAttrsJSON extends LicitElementAttrsJSON {
+    styleName?: string;
+    capco?: string;
+    selectionId?: string;
+}
+interface LicitHeaderContentJSON extends LicitElementJSON {
+    type: string;
+    text: string;
+    marks: LicitMarksJSON[];
+}
+interface LicitHeaderJSON extends LicitElementJSON {
+    type: string;
+    attrs: LicitHeaderAttrsJSON;
+    content: LicitHeaderContentJSON[];
+}
+interface LicitParagraphAttrsJSON extends LicitElementAttrsJSON {
+    styleName?: string;
+    align?: string;
+    indent?: number;
+}
+interface LicitParagraphContentJSON extends LicitElementJSON {
+    type: string;
+    text: string;
+    marks: LicitMarksJSON[];
+}
+interface LicitParagraphJSON extends LicitElementJSON {
+    type: string;
+    attrs: LicitParagraphAttrsJSON;
+    content: LicitParagraphContentJSON[];
+}
+interface LicitBulletListItemAttrsJSON extends LicitElementAttrsJSON {
+    styleName?: string;
+}
+interface LicitBulletListItemJSON extends LicitElementJSON {
+    type: string;
+    attrs: LicitBulletListItemAttrsJSON;
+    content: LicitParagraphJSON[];
+}
+interface LicitBulletListAttrsJSON extends LicitElementAttrsJSON {
+    id: string;
+    indent: number;
+    listStyleType: string;
+}
+interface LicitBulletListJSON extends LicitElementJSON {
+    type: 'bullet_list';
+    attrs: LicitBulletListAttrsJSON;
+    content: LicitBulletListItemJSON[];
+}
+interface LicitTableAttrsJSON extends LicitElementAttrsJSON {
+    marginLeft: null;
+    vignette: boolean;
+}
+interface LicitTableCellAttrsJSON extends LicitElementAttrsJSON {
+    colspan: number;
+    rowspan: number;
+    colwidth: number[] | number;
+    borderColor?: string;
+    borderTop?: string;
+    borderBottom?: string;
+    borderLeft?: string;
+    borderRight?: string;
+    background: string;
+    vignette?: boolean;
+    fullSize?: number;
+    vAlign?: string;
+}
+interface LicitTableCellJSON extends LicitElementJSON {
+    type: 'table_cell' | 'table_header';
+    attrs: LicitTableCellAttrsJSON;
+    content: LicitParagraphJSON[];
+}
+interface LicitTableCellImageJSON extends LicitElementJSON {
+    type: 'table_cell';
+    attrs: LicitTableCellAttrsJSON;
+    content: LicitParagraphImageJSON[];
+}
+interface LicitTableRowJSON extends LicitElementJSON {
+    type: 'table_row';
+    content: LicitTableCellJSON[];
+}
+export interface LicitTableJSON extends LicitElementJSON {
+    type: 'table';
+    attrs: LicitTableAttrsJSON;
+    content: LicitTableRowJSON[];
+}
+export declare abstract class LicitElement {
+    styleLevel: number;
+    id?: string;
+    abstract getBaseElement(): unknown;
+    abstract render(): LicitElementJSON;
+}
+interface LicitHRJSON extends LicitElementJSON {
+    type: string;
+    attrs: LicitHRAttrsJSON;
+}
+interface LicitHRAttrsJSON extends LicitElementAttrsJSON {
+    pageBreak: null;
+}
+interface LicitOrderedListJSON extends LicitElementJSON {
+    type: 'ordered_list';
+    attrs: LicitBulletListAttrsJSON;
+    content: LicitBulletListItemJSON[];
+}
+export interface LicitDocumentJSON extends LicitElementJSON {
+    type: 'doc';
+    attrs: LicitDocumentAttrsJSON;
+    content: LicitElementJSON[];
+}
+export declare class LicitDocumentElement extends LicitElement {
+    getBaseElement(): LicitDocumentJSON;
+    children: LicitElement[];
+    appendElement(element: LicitElement): void;
+    render(): LicitDocumentJSON;
+}
+export declare class LicitImageElement extends LicitElement {
+    source: string;
+    alt: string;
+    width?: string;
+    height?: string;
+    align?: string;
+    constructor(src: string, altText?: string, width?: string, height?: string, align?: string);
+    getBaseElement(): LicitImageJSON;
+    render(): LicitImageJSON;
+}
+export declare class LicitNewImageElement extends LicitElement {
+    getBaseElement(): {
+        type: string;
+        attrs: {
+            alt: string;
+            height: any;
+            src: string;
+            title: any;
+            width: any;
+            fitToParent: any;
+            simpleImg: string;
+            capco: string;
+        };
+    };
+    source: string;
+    alt: string;
+    width: string;
+    height: string;
+    capco: string;
+    constructor(src: string, width: string, height: string, altText?: string, capco?: string);
+    render(): {
+        type: string;
+        attrs: {
+            alt: string;
+            height: any;
+            src: string;
+            title: any;
+            width: any;
+            fitToParent: any;
+            simpleImg: string;
+            capco: string;
+        };
+    };
+}
+export declare class LicitParagraphImageElement extends LicitElement {
+    getBaseElement(): LicitParagraphImageJSON;
+    source: string;
+    alt: string;
+    width?: string;
+    height?: string;
+    capco?: string;
+    align?: string;
+    constructor(src: string, alt?: string, width?: string, height?: string, align?: string);
+    render(): LicitParagraphImageJSON;
+}
+export declare class LicitEnhancedImageElement extends LicitElement {
+    getBaseElement(): {
+        type: string;
+        attrs: {
+            id: string;
+            figureType: string;
+            orientation: string;
+            maximized: boolean;
+            isValidate: boolean;
+        };
+        content: any[];
+    };
+    body: LicitEnhancedImageBodyElement;
+    capco: LicitEnhancedTableFigureCapcoElement;
+    orientation: string;
+    constructor(orientation: string);
+    render(): {
+        type: string;
+        attrs: {
+            id: string;
+            figureType: string;
+            orientation: string;
+            maximized: boolean;
+            isValidate: boolean;
+        };
+        content: any[];
+    };
+    addBody(bodyObj: LicitEnhancedImageBodyElement): void;
+    addCapco(capcoObj: LicitEnhancedTableFigureCapcoElement): void;
+}
+export declare class LicitEnhancedImageBodyElement extends LicitElement {
+    image: LicitNewImageElement;
+    getBaseElement(): {
+        type: string;
+        content: any[];
+    };
+    constructor(img: LicitNewImageElement);
+    render(): {
+        type: string;
+        content: any[];
+    };
+}
+export declare class LicitHeaderElement extends LicitElement {
+    getBaseElement(): LicitHeaderJSON;
+    text: string;
+    subText: string;
+    align: string | null;
+    styleName: string;
+    capco: string;
+    selectionId?: string;
+    name?: string;
+    marks?: Mark[];
+    constructor(text?: string, subText?: string, styleLevel?: number, styleName?: string, capco?: string, node?: HTMLElement);
+    render(): LicitHeaderJSON;
+    setInnerlinks(node?: HTMLElement): void;
+    handleInlineStyles(node: HTMLElement): Mark[];
+    mapInlineStylesToMarks(inlineStyles: string[], inlineMarks: {
+        type: string;
+        attrs?: LicitAttrs;
+    }[]): void;
+}
+export declare class LicitParagraphNote extends LicitElement {
+    node: HTMLElement;
+    styleName: string;
+    capco: string;
+    constructor(node: HTMLElement);
+    getBaseElement(): LicitParagraphJSON;
+    render(): LicitParagraphJSON;
+}
+export declare class LicitParagraphElement extends LicitElement {
+    getBaseElement(): LicitParagraphJSON;
+    text: string;
+    align: string | null;
+    constructor(text?: string);
+    render(): LicitParagraphJSON;
+}
+export declare class NewLicitParagraphElement extends LicitElement {
+    text: string;
+    align: string | null;
+    node: NodeList;
+    marks: Mark[];
+    styleName: string;
+    selectionId?: string;
+    id?: string;
+    capco?: string;
+    indent: number;
+    name?: string;
+    overriddenLineSpacing?: boolean;
+    imgContent: string[];
+    lineSpacing?: string | null;
+    overriddenLineSpaceingValue?: string | null;
+    overriddenAlignValue?: string | null;
+    overriddenAlign?: boolean;
+    hangingindent?: boolean;
+    reset?: boolean;
+    constructor(node: HTMLElement, infoIconData?: HTMLOListElement[], renderedContentList?: Node[]);
+    setInnerlinks(node: HTMLElement): void;
+    ConvertMarks(node: HTMLElement, infoIconData?: HTMLOListElement[], renderedContentList?: Node[]): void;
+    private handleTextMark;
+    /**
+     * Modifies and processes the child nodes of a given HTML element, applying various transformations
+     * and extracting semantic marks based on the node type. Handles inline styles, anchors, strong/emphasis/underline tags,
+     * superscript/subscript, text color/highlight, images, spans, and paragraphs. Updates mark collections and invokes
+     * specialized parsing methods for each supported node type.
+     *
+     * @param n - The current HTML element node to process.
+     * @param infoIconData - An array of HTMLOListElement objects containing info icon data.
+     * @param tMark - An array of Mark objects representing text marks.
+     * @param mark_Colour - The color to apply to marks.
+     * @param node - The parent HTML element node.
+     * @param renderedContentList - (Optional) An array of Node objects representing rendered content.
+     * @param parentInlineMarks - (Optional) An array of Mark objects representing inline stlyes written for parent node.
+     */
+    modifyChildNodes(n: HTMLElement, infoIconData: HTMLOListElement[], tMark: Mark[], mark_Colour: string, node: HTMLElement, renderedContentList?: Node[], parentInlineMarks?: Mark[]): void;
+    private handleParagraph;
+    private handleSpan;
+    isEmptySpaceSpan(node: HTMLElement): boolean;
+    isLastCharNotEmpty(str: any): boolean;
+    addTrailingSpace(): void;
+    handleText(textNode: HTMLElement, myMark: Mark, isFirstSentenceBold: boolean, styleMarks?: {
+        type: string;
+        attrs?: LicitAttrs;
+    }[]): void;
+    checkForLinks(text: string, urlRegex: RegExp): RegExpMatchArray;
+    addLinks(text: string, urlRegex: RegExp, myMark: Mark): void;
+    addMark(textMark: Mark, newMark: Mark): Mark;
+    /**
+     * Extracts inline style marks from a DOM node and returns an array of mark objects.
+     *
+     * This function parses the `style` attribute of the given node, identifies supported inline styles
+     * (such as italic, bold, underline, text color, line height, and text alignment), and returns
+     * corresponding mark objects with their attributes. It also updates certain instance properties
+     * for overridden line spacing and alignment when those styles are detected.
+     *
+     * @param node - The DOM node from which to extract inline styles.
+     * @returns An array of objects representing inline style marks, each with a `type` and optional `attrs`.
+     */
+    fetchInlineStyles(node: HTMLElement): {
+        type: string;
+        attrs?: LicitAttrs;
+    }[];
+    mapInlineStylesToMarks(inlineStyles: string[], inlineMarks: {
+        type: string;
+        attrs?: LicitAttrs;
+    }[]): void;
+    handleCustomInlineStyle(inlineStyle: string, inlineMarks: {
+        type: string;
+        attrs?: LicitAttrs;
+    }[]): void;
+    private parseImage;
+    private parseUnderline;
+    private parseEmphisis;
+    private parseStrong;
+    private parseAnchor;
+    private applyLinkAndColorMarks;
+    private parseLinkText;
+    private setLink;
+    private parseFont;
+    handleClassName(className: string, mark: Mark): void;
+    getEmptyTextMark(): {
+        type: string;
+        marks: any[];
+        text: string;
+    };
+    hasFontDetails(n: HTMLElement): boolean;
+    parseSubMarks(n: any, mark: Mark, _hasOneChild: boolean, infoIconData?: HTMLOListElement[]): Mark;
+    private parseFontWithInfoicon;
+    private parseUnderlineWithInfoicon;
+    private parseEMWithInfoicon;
+    private parseStrongWithInfoicon;
+    private parseAnchorWithInfoIcon;
+    getBaseElement(): {
+        type: string;
+        attrs: {
+            styleName: string;
+            align: string;
+            indent: number;
+            id: string;
+            capco: string;
+            selectionId: string;
+            overriddenLineSpacing: boolean;
+            lineSpacing: string;
+            overriddenLineSpaceingValue: string;
+            overriddenAlignValue: string;
+            overriddenAlign: boolean;
+            hangingindent: boolean;
+            reset: boolean;
+        };
+        content: any;
+    };
+    getBoldMarks(node: HTMLElement): {
+        type: string;
+        marks: {
+            type: string;
+            attrs: {
+                overridden: boolean;
+            };
+        }[];
+        text: string;
+    };
+    getEmMarks(node: HTMLElement, data?: any): Mark;
+    getEmInfoIconMark(childNode: ChildNode, data?: any): Mark | undefined;
+    getUnderLineMarks(node: HTMLElement): {
+        type: string;
+        marks: {
+            type: string;
+            attrs: {
+                overridden: boolean;
+            };
+        }[];
+        text: string;
+    };
+    getSuperScriptMarks(node: HTMLElement, data?: any): {
+        type: string;
+        attrs: {
+            from: any;
+            to: any;
+            description: string;
+            infoIcon: {
+                name: string;
+                unicode: string;
+                selected: boolean;
+            };
+        };
+    } | {
+        type: string;
+        marks: {
+            type: string;
+            attrs: {
+                overridden: boolean;
+            };
+        }[];
+        text: string;
+    };
+    getHighLightAndTextColor(node: HTMLElement): Mark | undefined;
+    getSubscriptMarks(node: HTMLElement): {
+        type: string;
+        marks: {
+            type: string;
+            attrs: {
+                overridden: boolean;
+            };
+        }[];
+        text: string;
+    };
+    getLinkMarks(node: HTMLLinkElement): {
+        type: string;
+        marks: {
+            type: string;
+            attrs: {
+                href: string;
+                rel: string;
+                target: string;
+                title: any;
+            };
+        }[];
+        text: string;
+    };
+    getText(node: HTMLElement): {
+        type: string;
+        text: string;
+    };
+    getInfoIconJson(infoDescription: string, Data: InfoIconData): {
+        type: string;
+        attrs: {
+            from: any;
+            to: any;
+            description: string;
+            infoIcon: {
+                name: string;
+                unicode: string;
+                selected: boolean;
+            };
+        };
+    };
+    render(): {
+        type: string;
+        attrs: {
+            styleName: string;
+            align: string;
+            indent: number;
+            id: string;
+            capco: string;
+            selectionId: string;
+            overriddenLineSpacing: boolean;
+            lineSpacing: string;
+            overriddenLineSpaceingValue: string;
+            overriddenAlignValue: string;
+            overriddenAlign: boolean;
+            hangingindent: boolean;
+            reset: boolean;
+        };
+        content: any;
+    };
+}
+export declare class LicitErrorTextElement extends LicitElement {
+    getBaseElement(): {
+        type: string;
+        attrs: {
+            align: string;
+            color: any;
+            id: any;
+            indent: any;
+            lineSpacing: any;
+            paddingBottom: any;
+            paddingTop: any;
+        };
+        content: {
+            type: string;
+            marks: ({
+                type: string;
+                attrs: {
+                    overridden: boolean;
+                    color?: undefined;
+                };
+            } | {
+                type: string;
+                attrs: {
+                    color: string;
+                    overridden: boolean;
+                };
+            })[];
+            text: string;
+        }[];
+    };
+    text: string;
+    constructor(altText: string);
+    render(): {
+        type: string;
+        attrs: {
+            align: string;
+            color: any;
+            id: any;
+            indent: any;
+            lineSpacing: any;
+            paddingBottom: any;
+            paddingTop: any;
+        };
+        content: {
+            type: string;
+            marks: ({
+                type: string;
+                attrs: {
+                    overridden: boolean;
+                    color?: undefined;
+                };
+            } | {
+                type: string;
+                attrs: {
+                    color: string;
+                    overridden: boolean;
+                };
+            })[];
+            text: string;
+        }[];
+    };
+}
+export declare class LicitBulletListItemElement extends LicitElement {
+    getBaseElement(): LicitBulletListItemJSON;
+    node: HTMLElement;
+    constructor(_node: HTMLElement);
+    render(): LicitBulletListItemJSON;
+}
+export declare class LicitBulletListElement extends LicitElement {
+    getBaseElement(): LicitBulletListJSON;
+    listItems: LicitBulletListItemElement[];
+    indent: number;
+    constructor(indent: number);
+    addItem(item: LicitBulletListItemElement): void;
+    render(): LicitBulletListJSON;
+}
+export declare class LicitTableCellElement extends LicitElement {
+    getBaseElement(): LicitTableCellJSON;
+    text: string;
+    rowspan: number;
+    colspan: number;
+    bgColor: string;
+    align: string;
+    colwidth: [number];
+    vAlign: string;
+    constructor(text: string, bgColor?: string, alignment?: string, colWidth?: [number], verticalAlignment?: string);
+    render(): LicitTableCellJSON;
+}
+export declare class LicitTableCellParagraph extends LicitElement {
+    getBaseElement(): {
+        type: string;
+        attrs: {
+            colspan: number;
+            rowspan: number;
+            colwidth: [number];
+            background: string;
+            vAlign: string;
+        };
+        content: any[];
+    };
+    node: HTMLElement;
+    rowspan: number;
+    colspan: number;
+    bgColor: string;
+    colWidth: [number];
+    content: any[];
+    vAlign: string;
+    constructor(node: HTMLElement, bgColor?: string, colwidth?: [number], vericalAlignment?: string);
+    render(): {
+        type: string;
+        attrs: {
+            colspan: number;
+            rowspan: number;
+            colwidth: [number];
+            background: string;
+            vAlign: string;
+        };
+        content: any[];
+    };
+}
+export declare class NewLicitTableCellParagraph extends LicitElement {
+    getBaseElement(): {
+        type: string;
+        attrs: {
+            colspan: number;
+            rowspan: number;
+            colwidth: number | [number];
+            background: string;
+            vAlign: string;
+        };
+        content: any[];
+    };
+    node: HTMLElement;
+    rowspan: number;
+    colspan: number;
+    bgColor: string;
+    colWidth: [number];
+    content: any[];
+    vAlign: string;
+    constructor(node: HTMLElement, bgColor?: string, colwidth?: [number], vericalAlignment?: string);
+    render(): {
+        type: string;
+        attrs: {
+            colspan: number;
+            rowspan: number;
+            colwidth: number | [number];
+            background: string;
+            vAlign: string;
+        };
+        content: any[];
+    };
+}
+export declare class LicitTableCellImageElement extends LicitElement {
+    getBaseElement(): LicitTableCellImageJSON;
+    text: string;
+    src: string;
+    rowspan: number;
+    colspan: number;
+    height: string;
+    bgColor: string;
+    colWidth: [number];
+    alt: string;
+    fillImg: number;
+    fitToParent: number;
+    constructor(src: string, fillImg: number, fitToParent: number, bgColor?: string, imgHeight?: string, colWidth?: [number], alt?: string);
+    render(): LicitTableCellImageJSON;
+}
+export declare class LicitVignetteElement extends LicitElement {
+    getBaseElement(): {
+        type: string;
+        attrs: {
+            colspan: number;
+            rowspan: number;
+            colwidth: number[];
+            borderColor: string;
+            borderTop: string;
+            borderBottom: string;
+            borderLeft: string;
+            borderRight: string;
+            background: string;
+            vignette: boolean;
+        };
+        content: any[];
+    };
+    text: string;
+    src: string;
+    rowspan: number;
+    colspan: number;
+    borderColor: string;
+    bgColor: string;
+    isVignet: boolean;
+    width: number[];
+    content: any[];
+    constructor(node: Element, borderColor: string, bgColor: string, width: number);
+    ConvertElements(node: Element): void;
+    private convertDiv;
+    private processSpanChildren;
+    private processDivChildren;
+    handleVignetteSpan(pNode: any): void;
+    render(): {
+        type: string;
+        attrs: {
+            colspan: number;
+            rowspan: number;
+            colwidth: number[];
+            borderColor: string;
+            borderTop: string;
+            borderBottom: string;
+            borderLeft: string;
+            borderRight: string;
+            background: string;
+            vignette: boolean;
+        };
+        content: any[];
+    };
+}
+export declare class LicitTableCellParaElement extends LicitElement {
+    getBaseElement(): LicitTableCellJSON;
+    node: HTMLElement;
+    rowspan: number;
+    colspan: number;
+    bgColor: string;
+    colWidth: number[];
+    content: any[];
+    vAlign: string;
+    isTableHeader: boolean;
+    isTransparentTable: boolean;
+    constructor(node: HTMLElement, bgColor?: string, colwidth?: [number], vericalAlignment?: string, isTableHeader?: boolean, isTransparentTable?: boolean);
+    ConvertElements(node: HTMLElement): void;
+    processChildNode(childNode: ChildNode): void;
+    processChildOL(childNode: ChildNode): void;
+    processChildUL(childNode: ChildNode): void;
+    processTextNodes(node: any): void;
+    cleanupText(text: any): string;
+    removeNewLines(text: string): string;
+    removeBullets(text: string): string;
+    render(): LicitTableCellJSON;
+}
+export declare class LicitTableRowElement extends LicitElement {
+    getBaseElement(): LicitTableRowJSON;
+    cells: LicitTableCellElement[];
+    addCell(cell: LicitTableCellElement): void;
+    render(): LicitTableRowJSON;
+}
+export declare class LicitTableElement extends LicitElement {
+    getBaseElement(): LicitTableJSON;
+    rows: LicitTableRowElement[];
+    isVignette: boolean;
+    capco?: string;
+    constructor(isVignette?: boolean, capco?: string);
+    addRow(row: LicitTableRowElement): void;
+    render(): LicitTableJSON;
+}
+export declare class LicitEnhancedTableElement extends LicitElement {
+    getBaseElement(): {
+        type: string;
+        attrs: {
+            id: string;
+            figureType: string;
+            orientation: string;
+            maximized: boolean;
+            isValidate: boolean;
+        };
+        content: any[];
+    };
+    body: LicitEnhancedTableFigureBodyElement;
+    capco: LicitEnhancedTableFigureCapcoElement;
+    notes: LicitEnhancedTableNotesElement;
+    orientation: string;
+    constructor(orientation?: string);
+    render(): {
+        type: string;
+        attrs: {
+            id: string;
+            figureType: string;
+            orientation: string;
+            maximized: boolean;
+            isValidate: boolean;
+        };
+        content: any[];
+    };
+    addBody(bodyObj: LicitEnhancedTableFigureBodyElement): void;
+    addCapco(capcoObj: LicitEnhancedTableFigureCapcoElement): void;
+    addNotes(notesObj: LicitEnhancedTableNotesElement): void;
+    removeLastRow(): void;
+}
+export declare class LicitEnhancedTableFigureBodyElement extends LicitElement {
+    table: LicitTableElement;
+    getBaseElement(): {
+        content: any[];
+        type: string;
+    };
+    render(): {
+        content: any[];
+        type: string;
+    };
+    addTable(table: LicitTableElement): void;
+}
+export declare class LicitEnhancedTableFigureCapcoElement extends LicitElement {
+    text: string;
+    capco: string | null;
+    getBaseElement(): {
+        type: string;
+        attrs: {
+            form: string;
+            capco: string;
+            style: string;
+            isValidate: boolean;
+        };
+        content: any[];
+    };
+    constructor(capco: string);
+    render(): {
+        type: string;
+        attrs: {
+            form: string;
+            capco: string;
+            style: string;
+            isValidate: boolean;
+        };
+        content: any[];
+    };
+}
+export declare class LicitEnhancedTableNotesElement extends LicitElement {
+    paragraphs: NewLicitParagraphElement[];
+    constructor(paragraphNodes: HTMLElement[]);
+    getBaseElement(): {
+        type: string;
+        attrs: {
+            styleName: string;
+        };
+        content: any[];
+    };
+    render(): {
+        type: string;
+        attrs: {
+            styleName: string;
+        };
+        content: any[];
+    };
+}
+export declare class LicitHRElement extends LicitElement {
+    getBaseElement(): LicitHRJSON;
+    render(): LicitHRJSON;
+}
+export declare class LicitOrderedListElement extends LicitElement {
+    getBaseElement(): LicitOrderedListJSON;
+    listItems: LicitBulletListItemElement[];
+    indent: number;
+    constructor(indent: number);
+    addItem(item: LicitBulletListItemElement): void;
+    render(): LicitOrderedListJSON;
+}
+export declare function shouldSkipNext(className: string): boolean;
+export declare function getElementAlignment(imgEl: Element): string;
+export {};