jekyll-ham 1.0.2 → 1.1.1

data/assets/mermaid/diagrams/block/blockDB.d.ts

@@ -0,0 +1,54 @@
+import type { DiagramDB } from '../../diagram-api/types.js';
+import type { BlockConfig, Block, ClassDef } from './blockTypes.js';
+/**
+ * Called when the parser comes across a (style) class definition
+ * @example classDef my-style fill:#f96;
+ *
+ * @param id - the id of this (style) class
+ * @param styleAttributes - the string with 1 or more style attributes (each separated by a comma)
+ */
+export declare const addStyleClass: (id: string, styleAttributes?: string) => void;
+/**
+ * Called when the parser comes across a style definition
+ * @example style my-block-id fill:#f96;
+ *
+ * @param id - the id of the block to style
+ * @param styles - the string with 1 or more style attributes (each separated by a comma)
+ */
+export declare const addStyle2Node: (id: string, styles?: string) => void;
+/**
+ * Add a CSS/style class to the block with the given id.
+ * If the block isn't already in the list of known blocks, add it.
+ * Might be called by parser when a CSS/style class should be applied to a block
+ *
+ * @param itemIds - The id or a list of ids of the item(s) to apply the css class to
+ * @param cssClassName - CSS class name
+ */
+export declare const setCssClass: (itemIds: string, cssClassName: string) => void;
+export declare function typeStr2Type(typeStr: string): "circle" | "round" | "square" | "diamond" | "hexagon" | "rect_left_inv_arrow" | "lean_right" | "lean_left" | "trapezoid" | "inv_trapezoid" | "stadium" | "subroutine" | "cylinder" | "na" | "block_arrow" | "doublecircle";
+export declare function edgeTypeStr2Type(typeStr: string): string;
+export declare function edgeStrToEdgeData(typeStr: string): string;
+export declare const generateId: () => string;
+/**
+ * Return all of the style classes
+ */
+export declare const getClasses: () => Record<string, ClassDef>;
+declare const db: {
+    readonly getConfig: () => BlockConfig | undefined;
+    readonly typeStr2Type: typeof typeStr2Type;
+    readonly edgeTypeStr2Type: typeof edgeTypeStr2Type;
+    readonly edgeStrToEdgeData: typeof edgeStrToEdgeData;
+    readonly getLogger: () => Console;
+    readonly getBlocksFlat: () => Block[];
+    readonly getBlocks: () => Block[];
+    readonly getEdges: () => Block[];
+    readonly setHierarchy: (block: Block[]) => void;
+    readonly getBlock: (id: string) => Block;
+    readonly setBlock: (block: Block) => void;
+    readonly getColumns: (blockId: string) => number;
+    readonly getClasses: () => Record<string, ClassDef>;
+    readonly clear: () => void;
+    readonly generateId: () => string;
+};
+export type BlockDB = typeof db & DiagramDB;
+export default db;

data/assets/mermaid/diagrams/block/blockDetector.d.ts

@@ -0,0 +1,3 @@
+import type { ExternalDiagramDefinition } from '../../diagram-api/types.js';
+declare const plugin: ExternalDiagramDefinition;
+export default plugin;

data/assets/mermaid/diagrams/block/blockDiagram.d.ts

@@ -0,0 +1,2 @@
+import type { DiagramDefinition } from '../../diagram-api/types.js';
+export declare const diagram: DiagramDefinition;

data/assets/mermaid/diagrams/block/blockRenderer.d.ts

@@ -0,0 +1,15 @@
+import type { Diagram } from '../../Diagram.js';
+/**
+ * Returns the all the styles from classDef statements in the graph definition.
+ *
+ * @param text - The text with the classes
+ * @param diagObj - The diagram object
+ * @returns ClassDef - The styles
+ */
+export declare const getClasses: (text: any, diagObj: any) => any;
+export declare const draw: (text: string, id: string, _version: string, diagObj: Diagram) => Promise<void>;
+declare const _default: {
+    draw: (text: string, id: string, _version: string, diagObj: Diagram) => Promise<void>;
+    getClasses: (text: any, diagObj: any) => any;
+};
+export default _default;

data/assets/mermaid/diagrams/block/blockTypes.d.ts

@@ -0,0 +1,36 @@
+export type { BlockDiagramConfig as BlockConfig } from '../../config.type.js';
+export type BlockType = 'na' | 'column-setting' | 'edge' | 'round' | 'block_arrow' | 'space' | 'square' | 'diamond' | 'hexagon' | 'odd' | 'lean_right' | 'lean_left' | 'trapezoid' | 'inv_trapezoid' | 'rect_left_inv_arrow' | 'odd_right' | 'circle' | 'ellipse' | 'stadium' | 'subroutine' | 'cylinder' | 'group' | 'doublecircle' | 'classDef' | 'applyClass' | 'applyStyles' | 'composite';
+export interface Block {
+    start?: string;
+    end?: string;
+    arrowTypeEnd?: string;
+    arrowTypeStart?: string;
+    width?: number;
+    id: string;
+    label?: string;
+    intersect?: any;
+    parent?: Block;
+    type?: BlockType;
+    children: Block[];
+    size?: {
+        width: number;
+        height: number;
+        x: number;
+        y: number;
+    };
+    node?: any;
+    columns?: number;
+    classes?: string[];
+    directions?: string[];
+    css?: string;
+    styleClass?: string;
+    styles?: string[];
+    stylesStr?: string;
+    widthInColumns?: number;
+}
+export interface ClassDef {
+    id: string;
+    textStyles: string[];
+    styles: string[];
+}
+export type Direction = 'up' | 'down' | 'left' | 'right' | 'x' | 'y';

data/assets/mermaid/diagrams/block/blockUtils.d.ts

@@ -0,0 +1 @@
+export declare const prepareTextForParsing: (text: string) => string;

data/assets/mermaid/diagrams/block/layout.d.ts

@@ -0,0 +1,13 @@
+import type { BlockDB } from './blockDB.js';
+interface BlockPosition {
+    px: number;
+    py: number;
+}
+export declare function calculateBlockPosition(columns: number, position: number): BlockPosition;
+export declare function layout(db: BlockDB): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+} | undefined;
+export {};

data/assets/mermaid/diagrams/block/layout.spec.d.ts

@@ -0,0 +1 @@
+export {};

data/assets/mermaid/diagrams/block/parser/block.spec.d.ts

@@ -0,0 +1 @@
+export {};

data/assets/mermaid/diagrams/block/renderHelpers.d.ts

@@ -0,0 +1,10 @@
+import type { Block } from './blockTypes.js';
+import type { BlockDB } from './blockDB.js';
+declare function calculateBlockSize(elem: d3.Selection<SVGGElement, unknown, HTMLElement, any>, block: any, db: any): Promise<void>;
+type ActionFun = typeof calculateBlockSize;
+export declare function insertBlockPositioned(elem: any, block: Block, db: any): Promise<void>;
+export declare function performOperations(elem: d3.Selection<SVGGElement, unknown, HTMLElement, any>, blocks: Block[], db: BlockDB, operation: ActionFun): Promise<void>;
+export declare function calculateBlockSizes(elem: any, blocks: Block[], db: BlockDB): Promise<void>;
+export declare function insertBlocks(elem: d3.Selection<SVGGElement, unknown, HTMLElement, any>, blocks: Block[], db: BlockDB): Promise<void>;
+export declare function insertEdges(elem: any, edges: Block[], blocks: Block[], db: BlockDB, id: string): Promise<void>;
+export {};

data/assets/mermaid/diagrams/block/styles.d.ts

@@ -0,0 +1,18 @@
+/** Returns the styles given options */
+export interface BlockChartStyleOptions {
+    arrowheadColor: string;
+    border2: string;
+    clusterBkg: string;
+    clusterBorder: string;
+    edgeLabelBackground: string;
+    fontFamily: string;
+    lineColor: string;
+    mainBkg: string;
+    nodeBorder: string;
+    nodeTextColor: string;
+    tertiaryColor: string;
+    textColor: string;
+    titleColor: string;
+}
+declare const getStyles: (options: BlockChartStyleOptions) => string;
+export default getStyles;

data/assets/mermaid/diagrams/c4/c4Db.d.ts

@@ -0,0 +1,127 @@
+export function getC4Type(): any;
+export function setC4Type(c4TypeParam: any): void;
+export function addRel(type: any, from: any, to: any, label: any, techn: any, descr: any, sprite: any, tags: any, link: any): void;
+export function addPersonOrSystem(typeC4Shape: any, alias: any, label: any, descr: any, sprite: any, tags: any, link: any): void;
+export function addContainer(typeC4Shape: any, alias: any, label: any, techn: any, descr: any, sprite: any, tags: any, link: any): void;
+export function addComponent(typeC4Shape: any, alias: any, label: any, techn: any, descr: any, sprite: any, tags: any, link: any): void;
+export function addPersonOrSystemBoundary(alias: any, label: any, type: any, tags: any, link: any): void;
+export function addContainerBoundary(alias: any, label: any, type: any, tags: any, link: any): void;
+export function addDeploymentNode(nodeType: any, alias: any, label: any, type: any, descr: any, sprite: any, tags: any, link: any): void;
+export function popBoundaryParseStack(): void;
+export function updateElStyle(typeC4Shape: any, elementName: any, bgColor: any, fontColor: any, borderColor: any, shadowing: any, shape: any, sprite: any, techn: any, legendText: any, legendSprite: any): void;
+export function updateRelStyle(typeC4Shape: any, from: any, to: any, textColor: any, lineColor: any, offsetX: any, offsetY: any): void;
+export function updateLayoutConfig(typeC4Shape: any, c4ShapeInRowParam: any, c4BoundaryInRowParam: any): void;
+export function getC4ShapeInRow(): number;
+export function getC4BoundaryInRow(): number;
+export function getCurrentBoundaryParse(): string;
+export function getParentBoundaryParse(): string;
+export function getC4ShapeArray(parentBoundary: any): any[];
+export function getC4Shape(alias: any): any;
+export function getC4ShapeKeys(parentBoundary: any): string[];
+export function getBoundaries(parentBoundary: any): {
+    alias: string;
+    label: {
+        text: string;
+    };
+    type: {
+        text: string;
+    };
+    tags: null;
+    link: null;
+    parentBoundary: string;
+}[];
+export function getBoundarys(parentBoundary: any): {
+    alias: string;
+    label: {
+        text: string;
+    };
+    type: {
+        text: string;
+    };
+    tags: null;
+    link: null;
+    parentBoundary: string;
+}[];
+export function getRels(): any[];
+export function getTitle(): string;
+export function setWrap(wrapSetting: any): void;
+export function autoWrap(): boolean;
+export function clear(): void;
+export namespace LINETYPE {
+    let SOLID: number;
+    let DOTTED: number;
+    let NOTE: number;
+    let SOLID_CROSS: number;
+    let DOTTED_CROSS: number;
+    let SOLID_OPEN: number;
+    let DOTTED_OPEN: number;
+    let LOOP_START: number;
+    let LOOP_END: number;
+    let ALT_START: number;
+    let ALT_ELSE: number;
+    let ALT_END: number;
+    let OPT_START: number;
+    let OPT_END: number;
+    let ACTIVE_START: number;
+    let ACTIVE_END: number;
+    let PAR_START: number;
+    let PAR_AND: number;
+    let PAR_END: number;
+    let RECT_START: number;
+    let RECT_END: number;
+    let SOLID_POINT: number;
+    let DOTTED_POINT: number;
+}
+export namespace ARROWTYPE {
+    let FILLED: number;
+    let OPEN: number;
+}
+export namespace PLACEMENT {
+    let LEFTOF: number;
+    let RIGHTOF: number;
+    let OVER: number;
+}
+export function setTitle(txt: any): void;
+declare namespace _default {
+    export { addPersonOrSystem };
+    export { addPersonOrSystemBoundary };
+    export { addContainer };
+    export { addContainerBoundary };
+    export { addComponent };
+    export { addDeploymentNode };
+    export { popBoundaryParseStack };
+    export { addRel };
+    export { updateElStyle };
+    export { updateRelStyle };
+    export { updateLayoutConfig };
+    export { autoWrap };
+    export { setWrap };
+    export { getC4ShapeArray };
+    export { getC4Shape };
+    export { getC4ShapeKeys };
+    export { getBoundaries };
+    export { getBoundarys };
+    export { getCurrentBoundaryParse };
+    export { getParentBoundaryParse };
+    export { getRels };
+    export { getTitle };
+    export { getC4Type };
+    export { getC4ShapeInRow };
+    export { getC4BoundaryInRow };
+    export { setAccTitle };
+    export { getAccTitle };
+    export { getAccDescription };
+    export { setAccDescription };
+    export function getConfig(): import("../../config.type.js").C4DiagramConfig | undefined;
+    export { clear };
+    export { LINETYPE };
+    export { ARROWTYPE };
+    export { PLACEMENT };
+    export { setTitle };
+    export { setC4Type };
+}
+export default _default;
+import { setAccTitle } from '../common/commonDb.js';
+import { getAccTitle } from '../common/commonDb.js';
+import { getAccDescription } from '../common/commonDb.js';
+import { setAccDescription } from '../common/commonDb.js';

data/assets/mermaid/diagrams/c4/c4Detector.d.ts

@@ -0,0 +1,3 @@
+import type { ExternalDiagramDefinition } from '../../diagram-api/types.js';
+declare const plugin: ExternalDiagramDefinition;
+export default plugin;

data/assets/mermaid/diagrams/c4/c4Diagram.d.ts

@@ -0,0 +1,2 @@
+import type { DiagramDefinition } from '../../diagram-api/types.js';
+export declare const diagram: DiagramDefinition;

data/assets/mermaid/diagrams/c4/c4Renderer.d.ts

@@ -0,0 +1,12 @@
+export function setConf(cnf: any): void;
+export function drawBoundary(diagram: any, boundary: any, bounds: any): void;
+export function drawC4ShapeArray(currentBounds: any, diagram: any, c4ShapeArray: any, c4ShapeKeys: any): void;
+export function drawRels(diagram: any, rels: any, getC4ShapeObj: any, diagObj: any): void;
+export function draw(_text: any, id: any, _version: any, diagObj: any): void;
+declare namespace _default {
+    export { drawC4ShapeArray as drawPersonOrSystemArray };
+    export { drawBoundary };
+    export { setConf };
+    export { draw };
+}
+export default _default;

data/assets/mermaid/diagrams/c4/styles.d.ts

@@ -0,0 +1,2 @@
+export default getStyles;
+declare function getStyles(options: any): string;

data/assets/mermaid/diagrams/c4/svgDraw.d.ts

@@ -0,0 +1,36 @@
+export function drawRect(elem: any, rectData: any): import("../common/commonTypes.js").D3RectElement;
+export function drawImage(elem: any, width: any, height: any, x: any, y: any, link: any): void;
+export function drawRels(elem: any, rels: any, conf: any): void;
+export function drawC4Shape(elem: any, c4Shape: any, conf: any): any;
+export function insertDatabaseIcon(elem: any): void;
+export function insertComputerIcon(elem: any): void;
+export function insertClockIcon(elem: any): void;
+export function insertArrowHead(elem: any): void;
+export function insertArrowEnd(elem: any): void;
+export function insertArrowFilledHead(elem: any): void;
+export function insertDynamicNumber(elem: any): void;
+export function insertArrowCrossHead(elem: any): void;
+declare namespace _default {
+    export { drawRect };
+    export { drawBoundary };
+    export { drawC4Shape };
+    export { drawRels };
+    export { drawImage };
+    export { insertArrowHead };
+    export { insertArrowEnd };
+    export { insertArrowFilledHead };
+    export { insertDynamicNumber };
+    export { insertArrowCrossHead };
+    export { insertDatabaseIcon };
+    export { insertComputerIcon };
+    export { insertClockIcon };
+}
+export default _default;
+/**
+ * Draws an boundary in the diagram
+ *
+ * @param {any} elem - The diagram we'll draw to.
+ * @param {any} boundary - The boundary to draw.
+ * @param {any} conf - DrawText implementation discriminator object
+ */
+declare function drawBoundary(elem: any, boundary: any, conf: any): void;

data/assets/mermaid/diagrams/class/classDb.d.ts

@@ -0,0 +1,144 @@
+import type { ClassRelation, ClassNode, ClassNote, ClassMap, NamespaceMap, NamespaceNode } from './classTypes.js';
+export declare const setClassLabel: (_id: string, label: string) => void;
+/**
+ * Function called by parser when a node definition has been found.
+ *
+ * @param id - Id of the class to add
+ * @public
+ */
+export declare const addClass: (_id: string) => void;
+/**
+ * Function to lookup domId from id in the graph definition.
+ *
+ * @param id - class ID to lookup
+ * @public
+ */
+export declare const lookUpDomId: (_id: string) => string;
+export declare const clear: () => void;
+export declare const getClass: (id: string) => ClassNode;
+export declare const getClasses: () => ClassMap;
+export declare const getRelations: () => ClassRelation[];
+export declare const getNotes: () => ClassNote[];
+export declare const addRelation: (relation: ClassRelation) => void;
+/**
+ * Adds an annotation to the specified class Annotations mark special properties of the given type
+ * (like 'interface' or 'service')
+ *
+ * @param className - The class name
+ * @param annotation - The name of the annotation without any brackets
+ * @public
+ */
+export declare const addAnnotation: (className: string, annotation: string) => void;
+/**
+ * Adds a member to the specified class
+ *
+ * @param className - The class name
+ * @param member - The full name of the member. If the member is enclosed in `<<brackets>>` it is
+ *   treated as an annotation If the member is ending with a closing bracket ) it is treated as a
+ *   method Otherwise the member will be treated as a normal property
+ * @public
+ */
+export declare const addMember: (className: string, member: string) => void;
+export declare const addMembers: (className: string, members: string[]) => void;
+export declare const addNote: (text: string, className: string) => void;
+export declare const cleanupLabel: (label: string) => string;
+/**
+ * Called by parser when assigning cssClass to a class
+ *
+ * @param ids - Comma separated list of ids
+ * @param className - Class to add
+ */
+export declare const setCssClass: (ids: string, className: string) => void;
+export declare const getTooltip: (id: string, namespace?: string) => string | undefined;
+/**
+ * Called by parser when a link is found. Adds the URL to the vertex data.
+ *
+ * @param ids - Comma separated list of ids
+ * @param linkStr - URL to create a link for
+ * @param target - Target of the link, _blank by default as originally defined in the svgDraw.js file
+ */
+export declare const setLink: (ids: string, linkStr: string, target: string) => void;
+/**
+ * Called by parser when a click definition is found. Registers an event handler.
+ *
+ * @param ids - Comma separated list of ids
+ * @param functionName - Function to be called on click
+ * @param functionArgs - Function args the function should be called with
+ */
+export declare const setClickEvent: (ids: string, functionName: string, functionArgs: string) => void;
+export declare const bindFunctions: (element: Element) => void;
+export declare const lineType: {
+    LINE: number;
+    DOTTED_LINE: number;
+};
+export declare const relationType: {
+    AGGREGATION: number;
+    EXTENSION: number;
+    COMPOSITION: number;
+    DEPENDENCY: number;
+    LOLLIPOP: number;
+};
+/**
+ * Function called by parser when a namespace definition has been found.
+ *
+ * @param id - Id of the namespace to add
+ * @public
+ */
+export declare const addNamespace: (id: string) => void;
+/**
+ * Function called by parser when a namespace definition has been found.
+ *
+ * @param id - Id of the namespace to add
+ * @param classNames - Ids of the class to add
+ * @public
+ */
+export declare const addClassesToNamespace: (id: string, classNames: string[]) => void;
+export declare const setCssStyle: (id: string, styles: string[]) => void;
+declare const _default: {
+    setAccTitle: (txt: string) => void;
+    getAccTitle: () => string;
+    getAccDescription: () => string;
+    setAccDescription: (txt: string) => void;
+    getConfig: () => import("../../config.type.js").ClassDiagramConfig | undefined;
+    addClass: (_id: string) => void;
+    bindFunctions: (element: Element) => void;
+    clear: () => void;
+    getClass: (id: string) => ClassNode;
+    getClasses: () => ClassMap;
+    getNotes: () => ClassNote[];
+    addAnnotation: (className: string, annotation: string) => void;
+    addNote: (text: string, className: string) => void;
+    getRelations: () => ClassRelation[];
+    addRelation: (relation: ClassRelation) => void;
+    getDirection: () => string;
+    setDirection: (dir: string) => void;
+    addMember: (className: string, member: string) => void;
+    addMembers: (className: string, members: string[]) => void;
+    cleanupLabel: (label: string) => string;
+    lineType: {
+        LINE: number;
+        DOTTED_LINE: number;
+    };
+    relationType: {
+        AGGREGATION: number;
+        EXTENSION: number;
+        COMPOSITION: number;
+        DEPENDENCY: number;
+        LOLLIPOP: number;
+    };
+    setClickEvent: (ids: string, functionName: string, functionArgs: string) => void;
+    setCssClass: (ids: string, className: string) => void;
+    setLink: (ids: string, linkStr: string, target: string) => void;
+    getTooltip: (id: string, namespace?: string | undefined) => string | undefined;
+    setTooltip: (ids: string, tooltip?: string | undefined) => void;
+    lookUpDomId: (_id: string) => string;
+    setDiagramTitle: (txt: string) => void;
+    getDiagramTitle: () => string;
+    setClassLabel: (_id: string, label: string) => void;
+    addNamespace: (id: string) => void;
+    addClassesToNamespace: (id: string, classNames: string[]) => void;
+    getNamespace: (name: string) => NamespaceNode;
+    getNamespaces: () => NamespaceMap;
+    setCssStyle: (id: string, styles: string[]) => void;
+};
+export default _default;

data/assets/mermaid/diagrams/class/classDetector-V2.d.ts

@@ -0,0 +1,3 @@
+import type { ExternalDiagramDefinition } from '../../diagram-api/types.js';
+declare const plugin: ExternalDiagramDefinition;
+export default plugin;

data/assets/mermaid/diagrams/class/classDetector.d.ts

@@ -0,0 +1,3 @@
+import type { ExternalDiagramDefinition } from '../../diagram-api/types.js';
+declare const plugin: ExternalDiagramDefinition;
+export default plugin;

data/assets/mermaid/diagrams/class/classDiagram-v2.d.ts

@@ -0,0 +1,2 @@
+import type { DiagramDefinition } from '../../diagram-api/types.js';
+export declare const diagram: DiagramDefinition;

data/assets/mermaid/diagrams/class/classDiagram.d.ts

@@ -0,0 +1,2 @@
+import type { DiagramDefinition } from '../../diagram-api/types.js';
+export declare const diagram: DiagramDefinition;

data/assets/mermaid/diagrams/class/classDiagram.spec.d.ts

@@ -0,0 +1 @@
+export {};

data/assets/mermaid/diagrams/class/classRenderer-v2.d.ts

@@ -0,0 +1,57 @@
+import * as graphlib from 'dagre-d3-es/src/graphlib/index.js';
+import type { ClassRelation, ClassNote, ClassMap, NamespaceMap } from './classTypes.js';
+/**
+ * Function that adds the vertices found during parsing to the graph to be rendered.
+ *
+ * @param namespaces - Object containing the vertices.
+ * @param g - The graph that is to be drawn.
+ * @param _id - id of the graph
+ * @param diagObj - The diagram object
+ */
+export declare const addNamespaces: (namespaces: NamespaceMap, g: graphlib.Graph, _id: string, diagObj: any) => void;
+/**
+ * Function that adds the vertices found during parsing to the graph to be rendered.
+ *
+ * @param classes - Object containing the vertices.
+ * @param g - The graph that is to be drawn.
+ * @param _id - id of the graph
+ * @param diagObj - The diagram object
+ * @param parent - id of the parent namespace, if it exists
+ */
+export declare const addClasses: (classes: ClassMap, g: graphlib.Graph, _id: string, diagObj: any, parent?: string) => void;
+/**
+ * Function that adds the additional vertices (notes) found during parsing to the graph to be rendered.
+ *
+ * @param notes - Object containing the additional vertices (notes).
+ * @param g - The graph that is to be drawn.
+ * @param startEdgeId - starting index for note edge
+ * @param classes - Classes
+ */
+export declare const addNotes: (notes: ClassNote[], g: graphlib.Graph, startEdgeId: number, classes: ClassMap) => void;
+/**
+ * Add edges to graph based on parsed graph definition
+ *
+ * @param relations -
+ * @param g - The graph object
+ */
+export declare const addRelations: (relations: ClassRelation[], g: graphlib.Graph) => void;
+/**
+ * Merges the value of `conf` with the passed `cnf`
+ *
+ * @param cnf - Config to merge
+ */
+export declare const setConf: (cnf: any) => void;
+/**
+ * Draws a class diagram in the tag with id: id based on the definition in text.
+ *
+ * @param text -
+ * @param id -
+ * @param _version -
+ * @param diagObj -
+ */
+export declare const draw: (text: string, id: string, _version: string, diagObj: any) => Promise<void>;
+declare const _default: {
+    setConf: (cnf: any) => void;
+    draw: (text: string, id: string, _version: string, diagObj: any) => Promise<void>;
+};
+export default _default;

data/assets/mermaid/diagrams/class/classRenderer.d.ts

@@ -0,0 +1,5 @@
+export function draw(text: string, id: string, _version: any, diagObj: any): void;
+declare namespace _default {
+    export { draw };
+}
+export default _default;

data/assets/mermaid/diagrams/class/classTypes.d.ts

@@ -0,0 +1,78 @@
+export interface ClassNode {
+    id: string;
+    type: string;
+    label: string;
+    cssClasses: string[];
+    methods: ClassMember[];
+    members: ClassMember[];
+    annotations: string[];
+    domId: string;
+    styles: string[];
+    parent?: string;
+    link?: string;
+    linkTarget?: string;
+    haveCallback?: boolean;
+    tooltip?: string;
+}
+export type Visibility = '#' | '+' | '~' | '-' | '';
+export declare const visibilityValues: string[];
+/**
+ * Parses and stores class diagram member variables/methods.
+ *
+ */
+export declare class ClassMember {
+    id: string;
+    cssStyle: string;
+    memberType: 'method' | 'attribute';
+    visibility: Visibility;
+    /**
+     * denote if static or to determine which css class to apply to the node
+     * @defaultValue ''
+     */
+    classifier: string;
+    /**
+     * parameters for method
+     * @defaultValue ''
+     */
+    parameters: string;
+    /**
+     * return type for method
+     * @defaultValue ''
+     */
+    returnType: string;
+    constructor(input: string, memberType: 'method' | 'attribute');
+    getDisplayDetails(): {
+        displayText: string;
+        cssStyle: string;
+    };
+    parseMember(input: string): void;
+    parseClassifier(): "" | "font-style:italic;" | "text-decoration:underline;";
+}
+export interface ClassNote {
+    id: string;
+    class: string;
+    text: string;
+}
+export type ClassRelation = {
+    id1: string;
+    id2: string;
+    relationTitle1: string;
+    relationTitle2: string;
+    type: string;
+    title: string;
+    text: string;
+    style: string[];
+    relation: {
+        type1: number;
+        type2: number;
+        lineType: number;
+    };
+};
+export interface NamespaceNode {
+    id: string;
+    domId: string;
+    classes: ClassMap;
+    children: NamespaceMap;
+}
+export type ClassMap = Record<string, ClassNode>;
+export type NamespaceMap = Record<string, NamespaceNode>;