wt-huatu 1.3.4

package/index.d.ts

@@ -0,0 +1,1747 @@
+interface IPoint {
+    x: number;
+    y: number;
+}
+interface ILine {
+    anchor: IPoint;
+    ang: number;
+    slope: number;
+}
+interface IGeometryModel {
+    getPoint(pos: string | number, t?: number): IPoint | undefined;
+    getParam(name: string): number | undefined;
+    moveBy(dx: number, dy: number): IGeometryModel | undefined;
+    rotateBy(rotDeg: number, at?: IPoint): IGeometryModel | undefined;
+}
+interface ICurveFuncsByT {
+    px: (t: number) => number;
+    py: (t: number) => number;
+    dpx: (t: number) => number;
+    dpy: (t: number) => number;
+}
+interface ISegmentModel {
+    pStart: IPoint;
+    pEnd: IPoint;
+    getCurveFuncs(): ICurveFuncsByT;
+    getTofPoint(p: IPoint): number | undefined;
+    makeSubSeg(pStart: IPoint, pEnd: IPoint): ISegmentModel | undefined;
+    getTangentLineOfPoint(p: IPoint): ILine | undefined;
+    getNormalPoint(t: number, dist: number, dir: "right" | "left"): IPoint | undefined;
+}
+
+type TSvgLineJoin = "miter" | "round" | "bevel";
+type TSvgLineCap = "butt" | "round" | "square";
+interface ISvgBBoxMaxMin {
+    xMin: number;
+    xMax: number;
+    yMin: number;
+    yMax: number;
+}
+interface ISvgBBox {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    isDummy: boolean;
+    buildString(): string;
+    toMaxMins(): ISvgBBoxMaxMin;
+    getAnchor(): ISvgPoint;
+    getCenter(): ISvgPoint;
+    extendByStroke(strokeWidth: number): ISvgBBox;
+    copy(): ISvgBBox;
+    mergeAnother(box: ISvgBBox): ISvgBBox;
+    moveBy(dx: number, dy: number): ISvgBBox;
+    rotateAt(rotCenter: ISvgPoint, rotDeg: number): ISvgBBox;
+    scale(t: number): ISvgBBox;
+    buildRectSvg(withClass?: boolean): string;
+    mirrorAt(mirrorX?: boolean, mirrorY?: boolean, at?: ISvgPoint): ISvgBBox;
+}
+interface ISvgPoint {
+    x: number;
+    y: number;
+}
+interface ISvgPath {
+    realPoints: ISvgPoint[];
+    auxPoints: ISvgPoint[];
+    centers: ISvgPoint[];
+    bbox: ISvgBBox;
+    stroke?: IStrokeConfig;
+    fill?: IFillConfig;
+    marker?: IMarkerConfig;
+    clip?: string | ISvgClipPath;
+    pathTag: string;
+    models: IGeometryModel[];
+    getPathAttr(): string[];
+    buildPathData(): string;
+    buildPathHtmlOnly(id?: string): string;
+    buildHtml(additional?: string): string;
+    buildHtmlFull(stroke?: IStrokeConfig, fill?: IFillConfig, marker?: IMarkerConfig, clip?: ISvgClipPath | string): string;
+    duplicateTo(distance: number, dir: "right" | "left" | "in" | "out", lineJoin?: TSvgLineJoin): ISvgPath | undefined;
+}
+interface ISvgPathSegment extends ISvgPath {
+    isStartSeg: boolean;
+    closePath: boolean;
+    pStart: ISvgPoint;
+    pEnd: ISvgPoint;
+    auxModel: ISegmentModel | undefined;
+    buildSegPathData(): string;
+    moveBy(dx: number, dy: number): ISvgPathSegment | undefined;
+    rotateBy(rotDeg: number, at?: ISvgPoint): ISvgPathSegment | undefined;
+    reverse(): ISvgPathSegment | undefined;
+    makeSubPath(pStart: ISvgPoint, pEnd: ISvgPoint): ISvgPathSegment | undefined;
+}
+interface IFillConfig {
+    color?: string;
+    opacity?: number;
+    rule?: "nonzero" | "evenodd";
+}
+interface IStrokeConfig {
+    color?: string;
+    width?: number;
+    opacity?: number;
+    lineCap?: TSvgLineCap;
+    lineJoin?: TSvgLineJoin;
+    miterLimit?: number;
+    dashArray?: number[] | "none";
+    dashOffset?: number;
+}
+interface IPathConfigs {
+    stroke?: IStrokeConfig;
+    fill?: IFillConfig;
+    marker?: IMarkerConfig;
+    clip?: string | ISvgClipPath;
+}
+interface ISvgShape {
+    hasStroke: boolean;
+    hasFill: boolean;
+    stroke?: IStrokeConfig;
+    fill?: IFillConfig;
+    primaryColor: "fill" | "stroke";
+    secondaryColor?: "fill" | "stroke";
+    paths: ISvgPath[];
+    bbox: ISvgBBox;
+    setStroke(stroke: IStrokeConfig): void;
+    setFill(fill: IFillConfig): void;
+    getBBox(strokeWidth?: number): ISvgBBox;
+    buildHtml(fillColor?: string, fillOpacity?: number, strokeColor?: string, strokeWidth?: number): string;
+}
+type SvgUnitsType = "userSpaceOnUse" | "objectBoundingBox";
+interface ISvgPattern {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    units: SvgUnitsType;
+    contentUnits?: SvgUnitsType;
+    viewBox?: ISvgBBox;
+    paths: ISvgPath[];
+    buildHtml(id?: string): string;
+}
+interface ISvgMarker {
+    id: string;
+    units: "strokeWidth" | "userSpaceOnUse";
+    refX: number;
+    refY: number;
+    orient: number | "auto" | "auto-start-reverse";
+    viewBox: ISvgBBox;
+    preserveAspectRatio?: boolean;
+    stroke?: IStrokeConfig;
+    fill?: IFillConfig;
+    shape: ISvgShape;
+    buildMarkerSvg(id?: string, primaryColor?: string, secondaryColor?: string): string;
+}
+interface ISvgClipPath {
+    id?: string;
+    path?: ISvgPath;
+    paths?: ISvgPath[];
+    group?: ISvgGroup;
+}
+interface IMarkerConfig {
+    start?: string;
+    mid?: string;
+    end?: string;
+}
+type ISvgElement = ISvgPath | ISvgGroup | ISvgLayer;
+interface ISvgGroup {
+    bbox: ISvgBBox;
+    clipPath?: ISvgPath | string;
+    elements?: ISvgElement[];
+    stroke?: IStrokeConfig;
+    fill?: IFillConfig;
+    clip?: string | ISvgClipPath;
+    add(element: ISvgElement): void;
+    getBBox(): ISvgBBox;
+}
+interface ISvgLayer extends ISvgGroup {
+    name: string;
+    desc?: string;
+    visible: boolean;
+    zIndex: number;
+    indicator: string;
+    renderHtml(): string;
+}
+
+interface IHuatuYmlObj {
+    [key: string]: IHuatuYmlValueType;
+}
+type IHuatuYmlValueType = string | string[] | IHuatuYmlObj | undefined;
+interface IHuatuYmlLabelStyle extends IHuatuYmlObj {
+    ref?: string;
+    refs?: string;
+    style?: string;
+    styles?: string;
+    color?: string;
+    font?: string;
+    size?: string;
+    fontSize?: string;
+    align?: string;
+    textAlign?: string;
+    bold?: string;
+    italic?: string;
+    line?: string;
+    addLine?: string;
+}
+interface IHuatuYmlStyle extends IHuatuYmlObj {
+    ref: string;
+    fillColor?: string;
+    fillOpacity?: string;
+    fillPattern?: string;
+    fillGradient?: string;
+    fillRule?: string;
+    fill?: string | {
+        color?: string;
+        opacity?: string;
+        pattern?: string;
+        gradient?: string;
+        rule?: string;
+    };
+    strokeColor?: string;
+    strokeWidth?: string;
+    strokeOpacity?: string;
+    strokeLineCap?: string;
+    strokeLineJoin?: string;
+    strokeMiterLimit?: string;
+    strokeDashArray?: string;
+    strokeDashOffset?: string;
+    stroke?: string | {
+        color?: string;
+        width?: string;
+        opacity?: string;
+        lineCap?: string;
+        lineJoin?: string;
+        miterLimit?: string;
+        dashArray?: string;
+        dashOffset?: string;
+    };
+    markerStart?: string;
+    markerMid?: string;
+    markerEnd?: string;
+    marker?: string | {
+        start?: string;
+        mid?: string;
+        end?: string;
+    };
+    clip?: string;
+    mask?: string;
+}
+interface IHuatuYmlMarker extends IHuatuYmlObj {
+    type?: string;
+    size?: string;
+    len?: string;
+    length?: string;
+    len2?: string;
+    length2?: string;
+    r?: string;
+    r1?: string;
+    r2?: string;
+    degStart?: string;
+    roundCorner?: string;
+    color1?: string;
+    priColor?: string;
+    primaryColor?: string;
+    color2?: string;
+    secColor?: string;
+    secondaryColor?: string;
+    close?: string;
+    fillOpacity?: string;
+}
+interface IHuatuYmlPattern extends IHuatuYmlObj {
+    type?: string;
+    density?: string;
+    lineDensity?: string;
+    dotsDensity?: string;
+    squareDensity?: string;
+    color?: string;
+    opacity?: string;
+    rotDeg?: string;
+    deg?: string;
+    lineDeg?: string;
+    lineWeight?: string;
+    lineWidth?: string;
+    lineStyle?: string;
+    dashDensity?: string;
+    dashedDensity?: string;
+    dottedDensity?: string;
+    size?: string;
+    bgColor?: string;
+    background?: string;
+    bgOpacity?: string;
+    sparseK?: string;
+}
+interface IHuatuYmlSymbolArray extends IHuatuYmlObj {
+    symbol?: string;
+    sym?: string;
+    startPoint?: string;
+    start?: string;
+    from?: string;
+    desc?: string;
+    method?: string;
+    arrayMethod?: string;
+    deltaX?: string;
+    dx?: string;
+    deltaY?: string;
+    dy?: string;
+    count?: string;
+    countX?: string;
+    countY?: string;
+    center?: string;
+    centerPoint?: string;
+    at?: string;
+    rotDeg?: string;
+    rot?: string;
+    rotate?: string;
+    alignCenter?: string;
+    radius?: string;
+    r?: string;
+    scale?: string;
+    notRotate?: string;
+    noRotate?: string;
+    noRot?: string;
+    startDeg?: string;
+    initialDeg?: string;
+    iniDeg?: string;
+    deltaDeg?: string;
+    degDelta?: string;
+    degD?: string;
+    dDeg?: string;
+}
+interface IHuatuYmlJob extends IHuatuYmlObj {
+    desc?: string;
+    viewBox?: string;
+    viewArea?: string;
+    viewBetween?: string;
+    width?: string;
+    height?: string;
+    size?: string;
+    drawings?: string | string[];
+    config?: IHuatuConfigInYml;
+}
+interface IHuatuConfigInYml extends IHuatuYmlObj {
+    labelBackground?: string;
+    labelBackgroundColor?: string;
+    labelBg?: string;
+    labelBgColor?: string;
+    labelBorder?: string;
+    labelBorderColor?: string;
+    markCenters?: string;
+    markBezierAuxLines?: string;
+    markNamedPoints?: string;
+    markPathPoints?: string;
+    markSize?: string;
+    markPositions?: string;
+    markAnchors?: string;
+    printUnusedModule?: string;
+    showBBox?: string;
+    [key: string]: string | undefined;
+}
+
+/** This file holds all the data structures designed for WT Huatu, all the modelling will be placed here. */
+
+type IHuatuInputVarType = "number" | "text" | "color";
+interface IHuatuInputVar {
+    name: string;
+    type: IHuatuInputVarType;
+    value: number | string;
+}
+interface IHuatuComponentInputVars {
+    [name: string]: string | number;
+}
+interface IHuatuComponentPort {
+    anchor: ISvgPoint;
+    name: string;
+    idx?: number;
+    rayDeg: number;
+    attr?: "in" | "out" | "inout" | "unset" | "hiz" | "pu" | "pd";
+    minHoldLen: number;
+}
+interface IHuatuComponentPortSettled {
+    name: string;
+    anchor: ISvgPoint;
+    freeStart: ISvgPoint;
+    lineAng: number;
+    lineDeg: number;
+    isH: boolean;
+    isV: boolean;
+    minHoldLen: number;
+}
+/**
+ * Model of the definition of the Component
+ */
+interface IHuatuComponentDef {
+    name: string;
+    desc?: string;
+    def: IHuatuYmlObj;
+    inputVars: IHuatuInputVar[];
+    isValid: boolean;
+}
+type HuatuComponentPlacementRefPointType = "center" | "origin";
+type HuatuComponentPlacementMirrorType = "x" | "y" | "xy";
+/**
+ * Model of the instantiated component
+ */
+interface IHuatuComponentPlacement {
+    isValid: boolean;
+    name: string;
+    location: ISvgPoint;
+    def?: IHuatuComponentDef;
+    huatuDef?: IHuatuYmlObj;
+    huatu?: IHuatu;
+    givenInputVars: IHuatuComponentInputVars;
+    ports: IHuatuComponentPort[];
+    mirror?: HuatuComponentPlacementMirrorType;
+    rotDeg?: number;
+    refPointType: HuatuComponentPlacementRefPointType;
+    rotateLabel?: boolean;
+    getRefPoint(): ISvgPoint;
+}
+
+/** This file holds all the data structures designed for WT Huatu, all the modelling will be placed here. */
+
+interface IHuatuConfig {
+    labelBackground?: string;
+    labelBorder?: string;
+    markCenters?: boolean;
+    markBezierAuxLines?: boolean;
+    markNamedPoints?: string;
+    markPathPoints?: string;
+    markSize?: number;
+    markPositions?: string;
+    printUnusedModule?: boolean;
+    showBBox?: string;
+    noRefStyle?: boolean;
+}
+declare global {
+    var wtHuatuConfig: IHuatuConfig | undefined;
+    var buildType: SvgBuildType;
+    var huatuKatexCss: string;
+    var wthtJobBuildId: string;
+}
+interface IHuatuVar {
+    howGet: "direct" | "derived";
+    name: string;
+    value: number;
+    def?: string;
+}
+interface IHuatuPoint {
+    name: string;
+    howGet: "direct" | "derived" | "calculated" | "intersection";
+    x: number;
+    y: number;
+    toSvgPoint(): ISvgPoint;
+    toPoint(): IPoint;
+}
+interface IHuatuPointSeries {
+    name: string;
+    points: ISvgPoint[];
+    getPoint(idx: number): ISvgPoint | undefined;
+    count(): number;
+}
+interface ISolvedXPoints {
+    path1: string;
+    path2: string;
+    points: ISvgPoint[];
+}
+interface IResultResolveXPoints {
+    result: "Error" | "Invalid" | "Success";
+    errors: string[];
+    points: ISvgPoint[];
+}
+interface IHuatuPath {
+    name?: string;
+    path?: ISvgPath;
+    model?: IGeometryModel;
+}
+interface IHuatuPathSeries {
+    name?: string;
+    paths: ISvgPath[];
+    models: IGeometryModel[];
+}
+interface IHuatuLabelStylePure {
+    color?: string;
+    font?: string;
+    fontSize?: number;
+    textAlign?: string;
+    bold?: boolean;
+    italic?: boolean;
+    addLine?: string;
+}
+interface IHuatuLabelStyle extends IHuatuLabelStylePure {
+    name: string;
+    refStyles: IHuatuLabelStyle[];
+}
+interface IHuatuLabel extends IHuatuLabelStylePure {
+    text: string;
+    width: number;
+    height: number;
+    location?: ISvgPoint;
+    anchorOffset?: ISvgPoint;
+    rotDeg?: number;
+    /**
+     * The possible anchoring positions for a label are:
+        "tl" | "topleft"
+      | "tm" | "topmiddle"
+      | "tr" | "topright"
+      | "ml" | "middleleft"
+      | "mm" | "center" | "c" | "middlemiddle"
+      | "mr" | "middleright"
+      | "bl" | "bottomleft"
+      | "bm" | "bottommiddle"
+      | "br" | "bottomright";
+     */
+    anchorPos?: string;
+    styles: IHuatuLabelStyle[];
+}
+interface IHuatuStyle {
+    refStyles: IHuatuStyle[];
+    name?: string;
+    fillColor?: string;
+    fillOpacity?: number;
+    fillPattern?: string | IHuatuPattern;
+    fillRule?: "nonzero" | "evenodd";
+    fillGradient?: string;
+    strokeColor?: string;
+    strokeWidth?: number;
+    strokeOpacity?: number;
+    strokeLineCap?: TSvgLineCap;
+    strokeLineJoin?: TSvgLineJoin;
+    strokeMiterLimit?: number;
+    strokeDashArray?: number[] | "none";
+    strokeDashOffset?: number;
+    markerStart?: string | IHuatuMarker;
+    markerMid?: string | IHuatuMarker;
+    markerEnd?: string | IHuatuMarker;
+    clipPath?: string | IHuatuClipPath;
+    buildCss(): string;
+    buildSvgAttr(direct?: boolean): string;
+}
+interface IHuatuTransform {
+    x?: number;
+    y?: number;
+    rotCx?: number;
+    rotCy?: number;
+    rotDeg?: number;
+    scale?: number;
+}
+type SvgBuildType = "direct" | "linking";
+interface IHuatuFinalDraw {
+    getBBox(): ISvgBBox;
+    /**
+     * The functions used to build SVG HTML in the final draw, It is designed for
+     *  - HuatuDrawing, which has its own styles and transformations, and
+     *  - Label, which is defined in just one line
+     */
+    buildHtml(buildType: SvgBuildType): string;
+}
+interface IHuatuDrawing {
+    /**
+     * Shared style if applicable
+     */
+    style?: IHuatuStyle;
+    /**
+     * The Transform control is used to place symbol/Symbol Array/block, if it is required.
+     * x, y are used for all the possible type of elements
+     * rotCx, rotCy, rotDeg and scale will only be used by Symbol.
+     * Block could be moved by x/y, scale, and rotated
+     * Array and Layer will not accepted any transform
+     */
+    transform?: IHuatuTransform;
+    /**
+     * This switch will be only used for Symbol and Symbol Array.
+     * Since there is some case that one Symbol needs to be located/aligned
+     * at the top-left corner or center of the symbol.
+     * So here provide a switch, if the chart designer wants to specify this.
+     */
+    alignCenter?: boolean;
+    /** The Element going to draw */
+    element?: IHuatuDrawingElement;
+}
+interface IHuatuDrawingElement {
+    getBBox(style?: IHuatuStyle): ISvgBBox;
+    buildHtml(buildType: SvgBuildType, style?: IHuatuStyle, transform?: IHuatuTransform): string;
+}
+interface IHuatuDefinable {
+    magicId: string;
+    buildId(): string;
+    buildHtmlForDef(): string;
+    refCount: number;
+    alwaysInDef: boolean;
+}
+interface IHuatuCss {
+    magicId: string;
+    buildCss(): string;
+    refCount: number;
+}
+/**
+ * The interface for the modules that could having multiple Drawings/labels
+ */
+interface IHuatuDrawingGroup {
+    name: string;
+    desc?: string;
+    bbox: ISvgBBox;
+    elements: IHuatuFinalDraw[];
+    addElement(element: IHuatuFinalDraw): void;
+}
+/**
+ * A symbol defined by composing multiple paths. It will show as
+ */
+interface IHuatuSymbol {
+    viewBox?: ISvgBBox;
+}
+interface IHuatuSymbolArray {
+    name: string;
+    symbol: IHuatuSymbol;
+    arrayMethod: "polar" | "line" | "2d";
+    startPoint?: ISvgPoint;
+    deltaX: number;
+    deltaY: number;
+    /**
+     * This count will be shared when Array specified as Polar or Line type
+     * If specified as 2D, then countX and countY will work.
+     */
+    count: number;
+    countX: number;
+    countY: number;
+    center?: ISvgPoint;
+    startDeg?: number;
+    deltaDeg?: number;
+    alignCenter?: boolean;
+}
+interface IHuatuClipPath {
+    name: string;
+    paths: ISvgPath[];
+    clipRule?: "evenodd" | "nonzero";
+}
+interface IPatternParams {
+    type?: string;
+    lineDensity?: number;
+    rotDeg?: number;
+    lineWeight?: number;
+    lineStyle?: string;
+    dashDensity?: number;
+    size?: number;
+    color?: string;
+    opacity?: number;
+    bgColor?: string;
+    bgOpacity?: number;
+    sparseK?: number;
+}
+interface IHuatuPattern {
+    name: string;
+    pattern: ISvgPattern;
+    params?: IPatternParams;
+}
+interface IMarkerParams {
+    type?: string;
+    size?: number;
+    width?: number;
+    height?: number;
+    r?: number;
+    rx?: number;
+    ry?: number;
+    n?: number;
+    direction?: string;
+    centerEmpty?: boolean;
+    rIn?: number;
+    rOut?: number;
+    degOffset?: number;
+    degOpen?: number;
+    len?: number;
+    k?: number;
+    closeArrow?: boolean;
+    makeSmooth?: boolean;
+    primaryColor?: string;
+    secondaryColor?: string;
+    fillColor?: string;
+    fillOpacity?: number;
+    strokeColor?: string;
+    strokeWidth?: number;
+}
+interface IHuatuMarker {
+    name: string;
+    marker: ISvgMarker;
+    params?: IMarkerParams;
+}
+interface IHuatuJob {
+    huatu: IHuatu;
+    name: string;
+    desc?: string;
+    viewBox?: ISvgBBox;
+    width?: number;
+    height?: number;
+    drawings: IHuatuFinalDraw[];
+    defines: IHuatuDefinable[];
+    styles: IHuatuCss[];
+    config?: IHuatuConfig;
+    buildSvg(buildType: SvgBuildType, withSize?: boolean, width?: number, height?: number): string;
+    buildSvgOfScale(buildType: SvgBuildType, scale?: number): string;
+    buildHtml(buildType: SvgBuildType, indent?: boolean, withSize?: boolean): string;
+    buildSvgStandalone(buildType: SvgBuildType, indent?: boolean, withSize?: boolean): string;
+    getViewBoxWithoutLabels(): ISvgBBox;
+}
+interface IHuatuResolvingError {
+    title: string;
+    msgs?: string[];
+}
+interface IHuatu {
+    title?: string;
+    desc?: string;
+    config?: IHuatuConfig;
+    width?: number;
+    height?: number;
+    viewBox?: ISvgBBox;
+    vars: IHuatuVar[];
+    clips: IHuatuClipPath[];
+    patterns: IHuatuPattern[];
+    markers: IHuatuMarker[];
+    styles: IHuatuStyle[];
+    labelStyles: IHuatuLabelStyle[];
+    points: IHuatuPoint[];
+    pointSeries: IHuatuPointSeries[];
+    paths: IHuatuPath[];
+    pathSeries: IHuatuPathSeries[];
+    defines: IHuatuDefinable[];
+    blocks: IHuatuDrawingGroup[];
+    symbols: IHuatuSymbol[];
+    arrays: IHuatuSymbolArray[];
+    layers: IHuatuDrawingGroup[];
+    compDefs: IHuatuComponentDef[];
+    compPlacements: IHuatuComponentPlacement[];
+    draw?: IHuatuJob;
+    jobs: IHuatuJob[];
+    infos: string[];
+    warnings: string[];
+    resolvingErrors: IHuatuResolvingError[];
+    /**
+     * The final printer
+     */
+    buildSvg(buildType: SvgBuildType, jobName?: string): string;
+    buildSvgAsHtml(buildType: SvgBuildType, jobName?: string, indent?: boolean): string;
+    buildSvgStandalone(buildType: SvgBuildType, jobName?: string, indent?: boolean): string;
+}
+
+interface IKeyValueOptions {
+    keys: string[][];
+    qualifiers: {
+        [key: string]: "int[]" | "number[]" | string[] | ((input: string) => string | undefined);
+    };
+    allowAppend: string[];
+    splitCharWhenAppending?: string;
+    booleans: string[];
+    ints: string[];
+    numbers: string[];
+    blindGuess: {
+        [key: string]: string[] | ((input: string) => string | number | boolean | undefined);
+    };
+    subKeys?: {
+        [subKey: string]: IKeyValueOptions;
+    };
+}
+interface IKeyValueParsingResult<T> {
+    body: T;
+    orphans: string[];
+    unluckyOrphans: string[];
+    failedPairs: {
+        key: string;
+        value: string;
+    }[];
+    subKeys?: {
+        [subKey: string]: IKeyValueParsingResult<any>;
+    };
+}
+
+interface INumberRange {
+    start: number;
+    step: number;
+    end: number;
+    numbers: number[];
+    count(): number;
+}
+declare class NumberRange implements INumberRange {
+    start: number;
+    step: number;
+    end: number;
+    numbers: number[];
+    constructor(start: number, step: number, end: number);
+    count(): number;
+    static build0toN(n: number): NumberRange;
+}
+
+declare class HuatuPath implements IHuatuPath, IHuatuDrawingElement, IHuatuDefinable {
+    name?: string;
+    path?: ISvgPath;
+    model?: IGeometryModel;
+    refCount: number;
+    alwaysInDef: boolean;
+    magicId: string;
+    constructor(path?: ISvgPath, name?: string);
+    setModel(model: IGeometryModel): void;
+    buildId(): string;
+    buildHtmlForDef(): string;
+    buildHtml(buildType: SvgBuildType, style?: IHuatuStyle, transform?: IHuatuTransform): string;
+    getBBox(): ISvgBBox;
+    moveBy(dx: number, dy: number, name?: string): HuatuPath | undefined;
+    rotateBy(rotDeg: number, at?: ISvgPoint, name?: string): HuatuPath | undefined;
+    static model2Path(model: IGeometryModel): ISvgPath | undefined;
+    static fromModel(model: IGeometryModel, name?: string): HuatuPath;
+}
+
+declare class HuatuPathSeries implements IHuatuPathSeries, IHuatuDrawingElement, IHuatuDefinable {
+    name?: string;
+    paths: ISvgPath[];
+    models: IGeometryModel[];
+    refCount: number;
+    alwaysInDef: boolean;
+    magicId: string;
+    constructor(name?: string, paths?: ISvgPath[]);
+    buildId(): string;
+    buildHtmlForDef(): string;
+    buildHtml(buildType: SvgBuildType, style?: IHuatuStyle | undefined, transform?: IHuatuTransform | undefined): string;
+    getBBox(): ISvgBBox;
+    static fromModels(models: IGeometryModel[], name?: string): HuatuPathSeries;
+}
+
+declare class HuatuDrawingGroup implements IHuatuDrawingGroup, IHuatuDrawingElement {
+    name: string;
+    desc?: string;
+    bbox: ISvgBBox;
+    elements: IHuatuFinalDraw[];
+    bboxes: ISvgBBox[];
+    acceptStyle: boolean;
+    acceptTransform: boolean;
+    transformForSymbol: boolean;
+    linkable: boolean;
+    constructor(name: string, desc?: string);
+    getLinkId(): string;
+    addElement(element: IHuatuFinalDraw): void;
+    getBBox(style?: IHuatuStyle): ISvgBBox;
+    buildHtml(buildType: SvgBuildType, style?: IHuatuStyle, transform?: IHuatuTransform | undefined): string;
+}
+
+declare class HuatuSymbol extends HuatuDrawingGroup implements IHuatuSymbol, IHuatuDefinable {
+    refCount: number;
+    alwaysInDef: boolean;
+    magicId: string;
+    viewBox?: ISvgBBox;
+    constructor(name: string, desc?: string);
+    getWidth(): number;
+    getHeight(): number;
+    setViewBox(viewBox: ISvgBBox): void;
+    getBBox(style?: IHuatuStyle): ISvgBBox;
+    buildId(): string;
+    buildHtmlForDef(): string;
+    buildTransformStr(transform?: IHuatuTransform, alignCenter?: boolean): string;
+    buildSvgOfLink(style?: IHuatuStyle, transform?: IHuatuTransform, alignCenter?: boolean): string;
+}
+
+/**
+ * The class implementation of SVG Point.
+ */
+
+declare class SvgPattern implements ISvgPattern {
+    id: string;
+    units: SvgUnitsType;
+    contentUnits?: SvgUnitsType;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    paths: ISvgPath[];
+    viewBox?: ISvgBBox | undefined;
+    constructor(id: string, x?: number, y?: number, width?: number, height?: number);
+    setUnits(units: SvgUnitsType): void;
+    setContentUnits(units: SvgUnitsType): void;
+    setViewBox(box: ISvgBBox): void;
+    addPaths(...paths: ISvgPath[]): void;
+    buildHtml(id?: string): string;
+}
+
+declare class HuatuPattern implements IHuatuPattern, IHuatuDefinable {
+    static TYPES: {
+        [key: string]: string[];
+    };
+    name: string;
+    pattern: ISvgPattern;
+    params?: IPatternParams;
+    refCount: number;
+    alwaysInDef: boolean;
+    magicId: string;
+    constructor(name: string, pattern: ISvgPattern);
+    buildHtmlForDef(): string;
+    buildId(): string;
+    static getAllPatternTypes(): string[];
+    static buildPatternFromParams(params: IPatternParams): SvgPattern | string;
+}
+
+declare class HuatuClipPath implements IHuatuClipPath, IHuatuDefinable {
+    name: string;
+    paths: ISvgPath[];
+    magicId: string;
+    refCount: number;
+    alwaysInDef: boolean;
+    clipRule?: "evenodd" | "nonzero";
+    constructor(name: string, paths?: ISvgPath[]);
+    buildHtmlForDef(): string;
+    buildId(): string;
+}
+
+/**
+ * The class implementation of SVG Line.
+ */
+
+declare class SvgMarker implements ISvgMarker {
+    id: string;
+    units: "strokeWidth" | "userSpaceOnUse";
+    refX: number;
+    refY: number;
+    orient: number | "auto" | "auto-start-reverse";
+    viewBox: ISvgBBox;
+    preserveAspectRatio?: boolean;
+    stroke?: IStrokeConfig;
+    fill?: IFillConfig;
+    shape: ISvgShape;
+    constructor(id: string, shape: ISvgShape, orient: number | "auto" | "auto-start-reverse", refX?: number, refY?: number, stroke?: IStrokeConfig, fill?: IFillConfig);
+    buildMarkerSvg(id?: string, primaryColor?: string, secondaryColor?: string): string;
+    /** Static methods, and shortcut methods of build different markers, the only variant is the
+     * shape which is determined by different input parameters such as size, etc.
+     */
+    /** --- Circle --- */
+    static buildMarkerCircle(radius: number, fillColor?: string, fillOpacity?: number, strokeColor?: string, strokeWidth?: number): ISvgMarker;
+    /** --- Ellipse --- */
+    static buildMarkerEllipse(rx: number, ry: number, fillColor?: string, fillOpacity?: number, strokeColor?: string, strokeWidth?: number): ISvgMarker;
+    /** --- Rectangle --- */
+    static buildMarkerRect(w: number, h: number, fillColor?: string, fillOpacity?: number, strokeColor?: string, strokeWidth?: number): ISvgMarker;
+    /** --- Square --- */
+    static buildMarkerSquare(w: number, fillColor?: string, fillOpacity?: number, strokeColor?: string, strokeWidth?: number): ISvgMarker;
+    /** --- Cross --- */
+    static buildMarkerCross(w: number, strokeColor?: string, strokeWidth?: number): ISvgMarker;
+    /** --- Plus --- */
+    static buildMarkerPlus(w: number, strokeColor?: string, strokeWidth?: number): ISvgMarker;
+    /** --- Polygon --- */
+    static buildMarkerPolygon(radius: number, edgeCount: number, fillColor?: string, fillOpacity?: number, strokeColor?: string, strokeWidth?: number): ISvgMarker;
+    /** --- Rhombus --- */
+    static buildMarkerRhombus(width: number, height: number, fillColor?: string, fillOpacity?: number, strokeColor?: string, strokeWidth?: number): ISvgMarker;
+    /** --- Isosceles Triangle --- */
+    static buildMarkerIsoscelesTriangle(width: number, height: number, direction: "up" | "right" | "down" | "left", fillColor?: string, fillOpacity?: number, strokeColor?: string, strokeWidth?: number): ISvgMarker;
+    /** --- Star made by simple axises --- */
+    static buildMarkerStar(size: number, axisCount: number, strokeColor?: string, strokeWidth?: number): ISvgMarker;
+    /** --- Standard 5-angle star --- */
+    static buildMarkerStar5(size: number, centerEmpty?: boolean, fillColor?: string, fillOpacity?: number, strokeColor?: string, strokeWidth?: number): ISvgMarker;
+    /** --- Unified Star-Like Markers --- */
+    static buildMarkerStarUnified(axisCount: number, rIn: number, rOut: number, degOffset: number, fillColor?: string, fillOpacity?: number, strokeColor?: string, strokeWidth?: number, roundRadius?: number): ISvgMarker;
+    /** --- Heart --- */
+    static buildMarkerHeart(h1: number, ctrlLen1: number, deg1: number, farPointX: number, farPointY: number, deg2: number, ctrlLen2: number, ctrlLen3: number, h2: number, deg3: number, ctrlLen4: number, fillColor?: string, fillOpacity?: number, strokeColor?: string, strokeWidth?: number): ISvgMarker;
+    /** --- Arrow Head --- */
+    static buildArrowHead(type: "solid-angle" | "solid-two-angle" | "simple", length: number, openDeg: number, len2Ratio?: number, makeSmooth?: boolean, makeTriangle?: boolean, color?: string): ISvgMarker;
+    /** The predefined markers */
+    static preDefines: {
+        [id: string]: ISvgMarker;
+    };
+}
+
+declare class HuatuMarker implements IHuatuMarker, IHuatuDefinable {
+    static TYPES: {
+        [key: string]: string[];
+    };
+    name: string;
+    marker: ISvgMarker;
+    primaryColor?: string;
+    secondaryColor?: string;
+    refCount: number;
+    alwaysInDef: boolean;
+    magicId: string;
+    constructor(name: string, marker: ISvgMarker);
+    buildHtmlForDef(): string;
+    buildId(): string;
+    static getAllMarkerTypeWords(): string[];
+    static buildMarkerFromParams(name: string, params: IMarkerParams): SvgMarker | string;
+}
+
+interface IHuatuStyleParams {
+    styles?: string;
+    fill?: string;
+    fillOpacity?: number;
+    opaque?: number;
+    fillRule?: string;
+    fillColor?: string;
+    stroke?: string;
+    lineJoin?: string;
+    lineCap?: string;
+    strokeColor?: string;
+    strokeOpacity?: number;
+    strokeWidth?: number;
+    dashArray?: number[];
+    dashOffset?: number;
+    gradient?: string;
+    pattern?: string;
+    marker?: string;
+    clip?: string;
+    markerStart?: string;
+    markerMid?: string;
+    markerEnd?: string;
+}
+declare class HuatuStyle implements IHuatuStyle, IHuatuCss {
+    refStyles: HuatuStyle[];
+    name?: string;
+    fillColor?: string;
+    fillOpacity?: number;
+    fillPattern?: HuatuPattern;
+    fillRule?: "nonzero" | "evenodd";
+    fillGradient?: string;
+    strokeColor?: string;
+    strokeWidth?: number;
+    strokeOpacity?: number;
+    strokeLineCap?: TSvgLineCap;
+    strokeLineJoin?: TSvgLineJoin;
+    strokeMiterLimit?: number;
+    strokeDashArray?: number[] | "none";
+    strokeDashOffset?: number;
+    markerStart?: HuatuMarker;
+    markerMid?: HuatuMarker;
+    markerEnd?: HuatuMarker;
+    clipPath?: HuatuClipPath;
+    refCount: number;
+    magicId: string;
+    constructor(name?: string);
+    copyRefAttrs(): void;
+    buildAttrArray(): string[][];
+    buildCss(): string;
+    buildSvgAttr(direct?: boolean): string;
+    toPathConfigs(): IPathConfigs;
+    static buildStyleClassName(style: HuatuStyle): string;
+    static judgeStrokeWidth(style?: IHuatuStyle): number;
+    static buildForSvg(style?: IHuatuStyle, direct?: boolean): string;
+    static convertStyleToPathConfigs(style: HuatuStyle): IPathConfigs;
+    static optsFill: IKeyValueOptions;
+    static optsFillColorAndOpacity: IKeyValueOptions;
+    static optsStroke: IKeyValueOptions;
+    static optsMarker: IKeyValueOptions;
+    static optsStyle: IKeyValueOptions;
+}
+
+declare class HuatuSymbolArray extends HuatuDrawingGroup implements IHuatuSymbolArray {
+    static METHODS: string[];
+    symbol: HuatuSymbol;
+    arrayMethod: "polar" | "line" | "2d";
+    startPoint?: ISvgPoint;
+    deltaX: number;
+    deltaY: number;
+    /**
+     * This count will be shared when Array specified as Polar or Line type
+     * If specified as 2D, then countX and countY will work.
+     */
+    count: number;
+    countX: number;
+    countY: number;
+    center?: ISvgPoint;
+    startDeg?: number;
+    deltaDeg?: number;
+    alignCenter?: boolean;
+    transforms: IHuatuTransform[];
+    constructor(name: string, symbol: HuatuSymbol, desc?: string);
+    /**
+     * Resolve the Linear generation of the Symbol Array
+     * @param count The Count to place the symbol
+     * @param dx Interval in X-axis
+     * @param dy Interval in Y-axis
+     * @param scale Scale factor of the Symbol, could be a number, or a func like Si = f(i) where i is the growing index
+     */
+    configLine(startPoint: ISvgPoint, count: number, dx?: number, dy?: number, scale?: number | ((n: number) => number), rotDeg?: number): void;
+    /**
+     * Resolve the 2D generation of the Symbol Array
+     * @param countX The count in X-axis
+     * @param countY The Count in Y-axis
+     * @param dx Interval in X-axis
+     * @param dy Interval in Y-axis
+     * @param scale Scale factor of the symbol, it could be a number or a func like Sxy = f(ix, iy), where ix and iy
+     *              is the growing index in X- and Y-axis
+     */
+    config2D(startPoint: ISvgPoint, countX: number, countY: number, dx?: number, dy?: number, scale?: number | ((nx: number, ny: number) => number), rotDeg?: number): void;
+    /**
+     * Resolve the polar method of arraying
+     * @param count How many symbols should be arrayed
+     * @param center The center to make the Array, i.e. the center of rotating
+     * @param radius How far should be the symbol located from the center, it could be a function of rotating of Angle,
+     *               e.g. R = f(theta), here, the unit of theta is Radian(not degree), to make it convenient to import
+     *               existing math curves which does this way
+     * @param scale How large will the symbol be scaled to, it could be a function of radius
+     * @param startDeg The start rotating angle, in degree
+     * @param deltaDeg The Interval of the rotating angle
+     * @param symbolNotRotate A switch to make sure if the symbol should stay not rotated
+     */
+    configPolar(count: number, center: ISvgPoint, radius: number | ((theta: number) => number), scale?: number | ((radius: number) => number), // The Scale parameter, if could be the function of Radius
+    startDeg?: number, deltaDeg?: number, symbolNotRotate?: boolean): void;
+    static optsSymbolArray: IKeyValueOptions;
+}
+
+declare class HuatuLabelStyle implements IHuatuLabelStyle, IHuatuCss {
+    static PREDEFINED_FONT_NAMES: string[];
+    static DECORATION_LINES: string[];
+    static TEXT_ALIGNS: string[];
+    refStyles: HuatuLabelStyle[];
+    name: string;
+    color?: string;
+    font?: string;
+    fontSize?: number;
+    textAlign?: string;
+    bold?: boolean;
+    italic?: boolean;
+    addLine?: string;
+    lineHeight?: number;
+    refCount: number;
+    magicId: string;
+    constructor(name: string);
+    buildAttrArray(): string[][];
+    buildCss(): string;
+    getStylePure(): IHuatuLabelStylePure;
+    static makePureStyle(srcStyle: IHuatuLabelStylePure): IHuatuLabelStylePure;
+    static copyRefStyle(sty: IHuatuLabelStylePure, srcStyle: IHuatuLabelStylePure): IHuatuLabelStylePure;
+    static buildStyleClassName(style: HuatuLabelStyle): string;
+    static resolveFontName(font: string): string;
+    static getDecorationLine(decorLine: string): string | undefined;
+}
+
+declare class HuatuLabel implements IHuatuLabel, IHuatuFinalDraw {
+    static ANCHOR_POSITIONS: string[];
+    static DEFAULT_WIDTH: number;
+    static DEFAULT_FONT_SIZE: number;
+    text: string;
+    width: number;
+    height: number;
+    location: ISvgPoint;
+    rotDeg: number;
+    anchorPos: string;
+    anchorX: number;
+    anchorY: number;
+    anchorOffset: ISvgPoint;
+    compRotDeg?: number;
+    compRefPoint?: ISvgPoint;
+    styles: HuatuLabelStyle[];
+    color?: string;
+    font?: string;
+    fontSize?: number;
+    textAlign?: string;
+    bold?: boolean;
+    italic?: boolean;
+    addLine?: string;
+    lineHeight?: number;
+    bgColor?: string;
+    borderColor?: string;
+    constructor(text: string, width?: number, height?: number);
+    getRealLocation(): ISvgPoint;
+    getBBox(): ISvgBBox;
+    setAnchor(anchorPos: string): void;
+    makeAnchoringMove(): ISvgPoint | undefined;
+    buildEmbeddedStyle(): string;
+    buildHtml(buildType: SvgBuildType): string;
+    getStylePure(): IHuatuLabelStylePure;
+    adjustForComponent(placement: IHuatuComponentPlacement): void;
+}
+
+interface IHuatuTransformParams {
+    move?: string;
+    rotDeg?: string;
+    at?: string;
+    scale?: number;
+}
+
+interface IHuatuDrawingParams extends IHuatuStyleParams, IHuatuTransformParams {
+    alignCenter?: boolean;
+    radius?: number[];
+}
+interface IHuatuDrawingSmoothParams {
+    factor?: number;
+    mode?: string;
+}
+
+declare class HuatuBlock extends HuatuDrawingGroup implements IHuatuDefinable {
+    alwaysInDef: boolean;
+    refCount: number;
+    magicId: string;
+    constructor(name: string, desc?: string);
+    buildId(): string;
+    buildHtmlForDef(): string;
+    getLinkId(): string;
+}
+
+declare class HuatuLayer extends HuatuDrawingGroup {
+    constructor(name: string, desc?: string);
+}
+
+/**
+ * The class implementation of SVG BBOX (Bounding box).
+ */
+
+declare class SvgBBox implements ISvgBBox {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    isDummy: boolean;
+    constructor(x: number, y: number, w: number, h: number, dummy?: boolean);
+    copy(): ISvgBBox;
+    toMaxMins(): ISvgBBoxMaxMin;
+    getAnchor(): ISvgPoint;
+    getCenter(): ISvgPoint;
+    buildString(): string;
+    mergeAnother(box: ISvgBBox): ISvgBBox;
+    /** Here this function will extend the border 2*strokeWidth far away,
+     * It is not accurate, and might be not very correct since there is another
+     * factor that miter limit determines. So here it is just some simple
+     * and approximating method to estimate the boundary of the bbox with
+     * some stroke. To precisely estimate the extended bbox, we should examine
+     * every corner of the vertices of the path, and it is path dependent,
+     * will cost a lot of calculating effort. Please modify and optimize this
+     * if you have some better idea.
+     */
+    extendByStroke(strokeWidth: number): ISvgBBox;
+    moveBy(dx: number, dy: number): SvgBBox;
+    rotateAt(rotCenter: ISvgPoint, rotDeg: number): SvgBBox;
+    scale(t: number): SvgBBox;
+    buildRectSvg(withClass?: boolean): string;
+    mirrorAt(mirrorX?: boolean, mirrorY?: boolean, at?: ISvgPoint): SvgBBox;
+    static DUMMY: SvgBBox;
+    static mergeTwo: (box1: ISvgBBoxMaxMin, box2: ISvgBBoxMaxMin) => ISvgBBoxMaxMin;
+    static mergeBoxes: (boxes: ISvgBBox[]) => SvgBBox;
+    static buildCornerPoints(bbox: ISvgBBox): ISvgPoint[];
+    static fromMaxMins(xMin: number, xMax: number, yMin: number, yMax: number): SvgBBox;
+    static fromCenterWidthHeight(center: ISvgPoint, w: number, h: number): SvgBBox;
+    static rotateAt(bbox: ISvgBBox, rotCenter: ISvgPoint, rotDeg: number): SvgBBox;
+    static moveBy(bbox: ISvgBBox, dx: number, dy: number): SvgBBox;
+    static buildRectSvg(bbox: ISvgBBox, withClass?: boolean): string;
+    static parseFromTwoPoints(p1: ISvgPoint, p2: ISvgPoint): SvgBBox | undefined;
+}
+
+declare class HuatuJob implements IHuatuJob {
+    huatu: IHuatu;
+    name: string;
+    desc?: string | undefined;
+    drawings: IHuatuFinalDraw[];
+    defines: IHuatuDefinable[];
+    styles: IHuatuCss[];
+    viewBox?: ISvgBBox;
+    vbExplicit: boolean;
+    width?: number;
+    height?: number;
+    config?: IHuatuConfig;
+    constructor(huatu: IHuatu, name: string);
+    static HUATU_HUB_KATEX_CSS: string;
+    static getKatexCss: () => string;
+    buildStyleDefs(): string;
+    resolveDefineOfDrawingElement(element: IHuatuDrawingElement): void;
+    resolveDefineOfStyle(style: IHuatuStyle): void;
+    resolveDefineOfDrawing(drawing: IHuatuDrawing): void;
+    resolveDefineOfLabel(label: IHuatuLabel): void;
+    resolveDefineOfFinalDraw(draw: IHuatuFinalDraw): void;
+    resolveDefines(): void;
+    buildInnerSvg(buildType: SvgBuildType): string;
+    buildSvgOnly(inner: string, extraAttrs: string[][]): string;
+    buildWithEmptyMsg(): string;
+    buildSvg(buildType: SvgBuildType, withSize?: boolean, width?: number, height?: number): string;
+    buildSvgOfScale(buildType: SvgBuildType, scale?: number): string;
+    buildHtml(buildType: SvgBuildType, indent?: boolean, withSize?: boolean): string;
+    buildSvgStandalone(buildType: SvgBuildType, indent?: boolean, withSize?: boolean): string;
+    calcViewBox(): SvgBBox | undefined;
+    getViewBoxWithoutLabels(): ISvgBBox;
+    buildHtmlForComponent(): {
+        graphs: string;
+        labels: string;
+    };
+}
+
+declare class HuatuComponentDef implements IHuatuComponentDef {
+    static REGEX_INPUT_VAR_USE_MATCH: RegExp;
+    name: string;
+    desc?: string;
+    def: IHuatuYmlObj;
+    inputVars: IHuatuInputVar[];
+    isValid: boolean;
+    errors: IHuatuResolvingError[];
+    constructor(name: string, def?: string | IHuatuYmlObj);
+    defineFromString(url: string): void;
+    defineFromObj(obj: IHuatuYmlObj): void;
+    replaceInputVars(vars: IHuatuComponentInputVars): IHuatuYmlObj | string[];
+    parseInputVars(obj: IHuatuYmlObj): IHuatuResolvingError | undefined;
+    cleanDefObj(obj: IHuatuYmlObj): IHuatuYmlObj;
+}
+
+declare class HuatuComponentPlacement implements IHuatuComponentPlacement {
+    isValid: boolean;
+    name: string;
+    location: ISvgPoint;
+    def: HuatuComponentDef;
+    huatuDef?: IHuatuYmlObj;
+    huatu?: WtHuatu;
+    givenInputVars: IHuatuComponentInputVars;
+    ports: IHuatuComponentPort[];
+    mirror?: HuatuComponentPlacementMirrorType;
+    rotDeg?: number;
+    errors: IHuatuResolvingError[];
+    refPointType: HuatuComponentPlacementRefPointType;
+    rotateLabel?: boolean | undefined;
+    portsSettled: IHuatuComponentPortSettled[];
+    constructor(name: string, location: ISvgPoint, def: HuatuComponentDef, inputVars?: IHuatuComponentInputVars, mirror?: HuatuComponentPlacementMirrorType, rotateDeg?: number, refPointType?: HuatuComponentPlacementRefPointType, rotateLabel?: boolean);
+    setMirror(mirrorType: HuatuComponentPlacementMirrorType): void;
+    rotate(deg: number): void;
+    getRefPoint(): ISvgPoint;
+    adjustLabels(): void;
+    settlePorts(): void;
+    static REF_POINT_TYPES: string[];
+    static MIRROR_TYPES: string[];
+    static optsComponentPlacement: IKeyValueOptions;
+}
+
+declare class HuatuComponentPort implements IHuatuComponentPort {
+    anchor: ISvgPoint;
+    name: string;
+    idx?: number;
+    rayDeg: number;
+    attr?: "in" | "out" | "inout" | "unset" | "hiz" | "pu" | "pd";
+    minHoldLen: number;
+    constructor(name: string, anchor: ISvgPoint);
+    static optsComponentPort: IKeyValueOptions;
+    static isTwoPortsParallel: (p1: IHuatuComponentPortSettled, p2: IHuatuComponentPortSettled) => boolean;
+    static isTwoPortsPerpendicular: (p1: IHuatuComponentPortSettled, p2: IHuatuComponentPortSettled) => boolean;
+    static isTwoPortsOnSameLine: (p1: IHuatuComponentPortSettled, p2: IHuatuComponentPortSettled) => boolean;
+    static isTwoPortsFacing: (p1: IHuatuComponentPortSettled, p2: IHuatuComponentPortSettled) => boolean;
+}
+
+interface IHuatuNet {
+    name?: string;
+    magicId: string;
+    addWire(wire: IHuatuWire): void;
+    getWires(): IHuatuWire[];
+}
+interface IHuatuWire {
+    portFrom?: IHuatuComponentPortSettled;
+    pointFrom?: ISvgPoint;
+    portTo?: IHuatuComponentPortSettled;
+    pointTo?: ISvgPoint;
+    type: "auto" | "line" | "hv" | "vh" | "hvh" | "vhv" | "hvhv" | "hvhvh" | "vhvh" | "vhvhv" | string;
+    radius?: number | number[];
+    turn?: number;
+    turnX?: number;
+    turnY?: number;
+    turnAt?: ISvgPoint;
+    xMin?: number;
+    xMax?: number;
+    yMin?: number;
+    yMax?: number;
+    net?: IHuatuNet;
+}
+
+declare class HuatuNet implements IHuatuNet {
+    name?: string;
+    magicId: string;
+    constructor(name?: string);
+    wires: IHuatuWire[];
+    addWire(wire: IHuatuWire): void;
+    getWires(): IHuatuWire[];
+    resolveWirePoints(): void;
+}
+
+declare class WtHuatu implements IHuatu {
+    title?: string;
+    desc?: string;
+    config?: IHuatuConfig;
+    width?: number;
+    height?: number;
+    viewBox?: ISvgBBox;
+    vars: IHuatuVar[];
+    points: IHuatuPoint[];
+    pointSeries: IHuatuPointSeries[];
+    paths: HuatuPath[];
+    pathSeries: HuatuPathSeries[];
+    clips: HuatuClipPath[];
+    patterns: HuatuPattern[];
+    markers: HuatuMarker[];
+    styles: HuatuStyle[];
+    labelStyles: HuatuLabelStyle[];
+    arrays: HuatuSymbolArray[];
+    defines: IHuatuDefinable[];
+    symbols: HuatuSymbol[];
+    blocks: HuatuBlock[];
+    labels: IHuatuLabel[];
+    layers: HuatuLayer[];
+    compDefs: HuatuComponentDef[];
+    compPlacements: HuatuComponentPlacement[];
+    compPorts: HuatuComponentPort[];
+    solvedXPoints: ISolvedXPoints[];
+    nets: HuatuNet[];
+    draw?: HuatuJob;
+    jobs: HuatuJob[];
+    infos: string[];
+    warnings: string[];
+    resolvingErrors: IHuatuResolvingError[];
+    varErrors: string[];
+    pointErrors: string[];
+    constructor();
+    static REGEX_LABEL_DEF: RegExp;
+    static REGEX_WIRE_DEF: RegExp;
+    static REGEX_ANGLE_MARK_DEF: RegExp;
+    static REGEX_DIM_MARK_DEF: RegExp;
+    static REGEX_SHAPE_AND_DRAWING_DEF: RegExp;
+    /**
+     * The shortcut function to replace all the vars in an expression with actual values.
+     * @param expr The expression to be replaced
+     * @returns The result after replaced all the vars
+     */
+    replaceVars(expr: string): string;
+    /**
+     * A shortcut function to replace all the occurred point coordinates in a point composing expression
+     * @param expr The point coordinate consisting of something like `pA.x`
+     * @returns The expression with `pA.x` replaced with 3 and `pA.y` with 4,
+     * if `pA = (3, 4)`
+     */
+    replaceCoors(expr: string): string;
+    replaceModelParams(expr: string): string;
+    /**
+     * The function to resolve a user input VAR
+     * @param expr The user input of a VAR
+     * @returns the resolved result of the VAR
+     */
+    resolveVarExpr(expr: string): number | undefined;
+    /**
+     * Resolve the var provided, and add it into var list.
+     * If some error encountered, then some error message will be returned.
+     * @param name Name of the var
+     * @param value Presentation of the var
+     */
+    resolveVar(name: string, value: string): string[];
+    addPoint(point: IHuatuPoint): void;
+    /**
+     * The unified method to resolve/calculate the X/Y coordinate of a Point.
+     * It can resolve some thing like `pA.x + sin(b) * (5 + r) + pB.y`
+     * It will replace the coors of other point(s) and replace functions and vars
+     * Then finally evaluate the result.
+     * @param expr The expression of X/Y coordinate of a Point
+     * @returns The resolved coordinate, a number
+     */
+    resolvePointCoorsExpr(expr: string): number | undefined;
+    /**
+     * Resolve a point from some PointSeries(with index) or Some Point (by name), or
+     * from the definition of XY coordinates.
+     * @param expr The string to query of build a point
+     * @returns The identified point or undefined
+     */
+    resolvePointFromExpr(expr: string): ISvgPoint | undefined;
+    /**
+     * Resolve the point directly defined, by supplying name and definition
+     * @param name name of the point
+     * @param value Presented form to calculate the point
+     */
+    resolvePoint(name: string, value: string): string[];
+    resolveSeparatedNumbers(def: string): number[];
+    /**
+     * This function is some unified method to resolve the (Geometry) Model of the shape defined by user.
+     * This function is normally only be used under this module.
+     * @param def The Definition string to build/specify one Shape, e.g. "circle;p0;5" means making some circle
+     *            centered at point p0 and having radius of 5
+     * @returns Error Message if errored or the resolved Model of the shape
+     */
+    resolveShapeDef(def: string): IGeometryModel | string;
+    /**
+     * The sub function to resolve the input of duplication-to defines
+     * @param def The definition string for the duplication
+     * @param withLineJoin A switch to determine whether introducing Line Join features, this is specialized for Segged-Path
+     *                     Because for basic types, there will be no such issue, it will always be smooth and consistent
+     * @returns
+     */
+    tryAsPathDuplication(def: string, withLineJoin?: boolean): ISvgPath | string | undefined;
+    /**
+     * Resolve the shape definitions
+     * @param name Name of the shape
+     * @param value Presentation to define the shape
+     * @returns Error message
+     */
+    resolveShape(name: string, value: string): string[];
+    tryPointOrPointSeries(def?: string): IPoint[] | undefined;
+    tryNumberSeries(def?: string): number[];
+    resolveShapesFromDef(def: string): IGeometryModel[] | string;
+    /**
+     * Resolve the Shape Series defined
+     * @param name Name of the shape series
+     * @param value The definition of the series
+     * @returns Error message if any
+     */
+    resolveShapeSeries(name: string, value: string): string[];
+    getResolvedXPoints(id1: string, id2: string): ISvgPoint[] | undefined;
+    makeXPoints(id1: string, id2: string): IResultResolveXPoints;
+    /**
+     * Resolve the Intersection point
+     * @param name Name of the intersection point
+     * @param value Presentation to resolve the point
+     * @returns Error message
+     */
+    resolveXPoint(name: string, value: string): string[];
+    /**
+     * Resolve Calculated Point, this normally will get e.g. some point on a circle,
+     * center(s) of a triangle, middle point of some line-segment, etc.
+     * @param name Name of the Calculated point
+     * @param value Presentation to resolve the point, the possible format of the CPoint:
+     *  - circle; deg             deg running along the circle, e.g. 'c1;30'
+     *  - ellipse; deg            deg running along the ellipse e.g. 'ell1; -90'
+     *  - line; l,                l could be any value
+     *  - lineseg; t              t in [0, 1]
+     *  - bezier2; t              t in [0, 1]
+     *  - bezier3; t              t in [0, 1]
+     *  - polygon; N; [t]         t-th point on the N-th side, t has the same meaning of lineseg, if t is not present, then N is the N-th vertex
+     *  - polyline; N; [t]        t- th point on the N-th seg, t has the same meaning of Lineseg, if t is not  present, then N is the N-th point
+     *  - arc; t                  t-th point on the arc, from start angle to end ang, i.e. t=0 means start, and t=1 means end
+     *  - triangle; 1/2/3; [t]    t-th point on the 1/2/3-th side, t has the same meaning of lineseg, is t is not present, then it means vertex
+     *  - triangle; cIn/cOut      Center of the inner/outer circle
+     *  - triangle; cG            Center of gravity
+     *  - triangle; A/B/C         1/2/3-th vertex of the triangle
+     *  - rectangle; nw/sw/se/ne        nw/sw/se/ne vertex point of the rect
+     *  - rectangle; n/w/s/e; t         t-th point on the N/W/S/E side, t has the same meaning of lineseg
+     *  - rectangle; nm/wm/sm/em        middle point on N/W/S/E side, easy to see that 'nm' means 'n; 0.5'
+     * @returns Error message
+     */
+    resolveCPoint(name: string, value: string): string[];
+    /**
+     * A small function to resolve the Range definition input by use
+     * @param def The definition string for a range, it should be like 'start|step|end'
+     * @returns The resolved range, or undefined if resolve failed
+     */
+    resolveRange(def?: string): NumberRange | undefined;
+    /**
+     * Resolve the Point Series definitions
+     * @param name Name of the Point Series
+     * @param value The definition string of the Point Series, e.g. "circ1; 0 | 15 | 60", which means get the points on
+     *              Circle "circ1", with the degrees starting from 0 to 60(not included) with interval of 15.
+     *              And we can the format of "0 | 15 | 60" a range
+     * The possible formats that could produce point series are:
+     *  - p1; p2; p3; p4; ...     Just simple list of defined points
+     *  - circle; deg[] or deg_range    Discrete degs or deg range running along the circle, e.g. 'c1;0 | 5 | 50' or 'c1; 0, 23, 33, 44'
+     *  - ellipse; deg[] or deg_range   Discrete degs or deg range running along the Ellipse, e.g. 'ell1; 20 | 5 | 180' or 'ell1; 3, 4, 8, 90'
+     *  - line; l[] or l_range,         Discrete length collection or a range of length
+     *  - lineseg; t[] or t_range       Discrete t's or range of t, t need to be in [0, 1];
+     *  - bezier2; t[] or t_range       Discrete t's or range of t, t need to be in [0, 1];
+     *  - bezier3; t[] or t_range       Discrete t's or range of t, t need to be in [0, 1];
+     *  - polygon; N; t[]               Discrete t's or range of t, on the N-th side of Polygon
+     *  - polygon; n1, n2, n3,...       The n-th vertex of the polygon, n1, n2, n3... need to be in [1, N]
+     *  - polyline; N; [t]              Discrete t's or range of t, on the N-th segment of Polyline, N needs to be in [1, N-1]
+     *  - polyline; n1, n2, n3,...      The n-th point of Polyline, n1, n2, n3... needs to be in [1, N]
+     *  - arc; t[] or t_range           Discrete t's or range of t, t need to be in [0, 1];
+     *  - triangle; [1/2/3/A/B/C/cIn/cOut/cG]     The 1/2/3/A/B/C/cIn/cOut/cG point of the triangle, in collection
+     *  - rectangle; [nw/sw/se/ne/nm/wm/sm/em/n/e/s/w]    nw/sw/se/ne/nm/wm/sm/em/n/e/s/w point of the rect, in collection, same meaning as in CPoint resolving
+     *  - rectangle; north/west/south/east; t[] or t_range      t's or range of t points on the N/W/S/E side, t is in [0, 1]
+     * @returns Error Message if any
+     */
+    resolvePointSeries(name: string, value: string): string[];
+    /**
+     * A shortcut function to resolve a single segment which is one of the compound path.
+     * Only the Valid segment types, i.e. LineSeg, Arc, Bezier2 and Bezier3 are accepted
+     * as segments
+     * @param def The input of the segment
+     * @returns The resolved segmented path, or close mark
+     */
+    resolveSegmentedPath(def: string): ISvgPathSegment | ISvgPathSegment[] | "CLOSE_MARK" | undefined;
+    tryPathTransform(def: string, name?: string): HuatuPath | undefined;
+    /**
+     * Resolve Path definition, the input might be a string, or string array
+     * @param name Name of the Calculated point
+     * @param value Presentation to resolve the path
+     * @returns Error message
+     */
+    resolvePath(name: string, value: string | string[]): string[];
+    /**
+     * Check if the user has given a valid string to specify the pattern, if it is a name for "predefined"
+     * pattern, then the pattern will be copied into the in-use collection with the same name. Or it
+     * needs to be some pattern defined by user manually.
+     * @param ptn The defined name or pre-defined name for the Pattern user wants to use
+     * @returns The Pattern or undefined if not found
+     */
+    checkPattern(ptn: string): HuatuPattern | undefined;
+    /**
+     * Check if the user has given a valid string to specify the marker, if it is a name for "predefined"
+     * marker, then the marker will be copied into the in-use collection with the same name. Or it
+     * needs to be some marker defined by user manually.
+     * @param ptn The defined name or pre-defined name for the Marker user wants to use
+     * @returns The Marker or undefined if not found
+     */
+    checkMarker(mkr: string): HuatuMarker | undefined;
+    parseStyleFromKeyValueResults(parseRes: IKeyValueParsingResult<IHuatuDrawingParams>): HuatuStyle;
+    /**
+     * Resolve Style definition, the input might be a string, or a style object
+     * @param name Name of the style
+     * @param value Presentation to resolve the style
+     * @returns Error message
+     */
+    resolveStyle(name: string, value: string | IHuatuYmlStyle): string[];
+    /**
+     * The entry function to resolve a LabelStyle defined
+     * @param name Name of the LabelStyle defined
+     * @param value The definition string/object for the LabelStyle
+     * @returns Error message if any
+     */
+    resolveLabelStyle(name: string, value: string | IHuatuYmlLabelStyle): string[];
+    /**
+     * Resolve Symbol definition, the input might be a string, or a string list
+     * @param name Name of the Symbol
+     * @param value Presentation to resolve the symbol
+     * @returns Error message
+     */
+    resolveSymbol(name: string, value: string | string[]): string[];
+    /**
+     * A tool function to convert the user-defined radius-/scale-function into Function
+     * and check if the function could produce valid result, which should be positive number.
+     * @param funcDef The definition of the function, e.g. 'x => (x + 2)*1.5
+     * @param paramCount How many inputs the function will take, normally, 1 or 2
+     * @returns The function or undefined
+     */
+    testUserFunc(funcDef: string, paramCount: number): Function | undefined;
+    /**
+     * Resolve Array definition, the input might be a string, or the object describing the array
+     * @param name Name of the Array
+     * @param value Presentation to resolve the array, shortcut string, or the object
+     * @returns Error message
+     */
+    resolveArray(name: string, value: string | IHuatuYmlSymbolArray): string[];
+    /**
+     * Resolve Clip Path definition, the input might be a string, or a string list
+     * @param name Name of the Clip Path
+     * @param value Presentation to resolve the clip path
+     * @returns Error message
+     */
+    resolveClip(name: string, value: string | string[]): string[];
+    /**
+     * Resolve Pattern definition, the input might be an object, describe how the pattern is designed
+     * @param name Name of the Pattern
+     * @param value Presentation to resolve the pattern
+     * @returns Error message
+     */
+    resolvePattern(name: string, value: string | IHuatuYmlPattern): string[];
+    /**
+     * Resolve Marker definition, the input might be an object, describe how the marker is designed
+     * @param name Name of the Marker
+     * @param value Presentation to resolve the Marker
+     * @returns Error message
+     */
+    resolveMarker(name: string, value: string | IHuatuYmlMarker): string[];
+    parseLabelDef(format: string, text: string): HuatuLabel | string;
+    parseStyleAndTransformString(def: string): {
+        style?: IHuatuStyle;
+        transform?: IHuatuTransform;
+        alignCenter?: boolean;
+        smooth?: IHuatuDrawingSmoothParams;
+        radius?: number[];
+    };
+    /**
+     * Resolve the "modelled" drawing by definition
+     * @param def The definition of the drawing of a shape, It might have two formats:
+     *             - Ad-Hoc Shape definitions and style/transform settings
+     *             - Referring a defined (named) module, and specifying style/transform
+     * @param allowedTypes The allowed sets of module that this function call will search, it is designed in the way that
+     *                     Different Drawing Group will accept different types of modules   *
+     * @returns The resolved Drawing or error message
+     */
+    resolveDrawingOfShapes(def: string, allowedTypes: string[]): IHuatuFinalDraw | string;
+    resolveWireTerminal(def?: string): IHuatuComponentPortSettled | IHuatuPoint | ISvgPoint | undefined;
+    parseWireDef(def: string): IHuatuFinalDraw | string;
+    parseAngleMarkDef(def: string): IHuatuFinalDraw | string;
+    parseDimMarkDef(def: string): IHuatuFinalDraw | string;
+    /**
+     * Unified function to resolve drawing definition
+     * @param def The unified definition of a "drawing", including a label, or named modules
+     * @param allowedTypes See the explanation in function `resolveDrawingOfShapes`
+     * @returns The final draw or error message
+     */
+    resolveAsDrawingItem(def: string, allowedTypes: string[]): IHuatuFinalDraw | string;
+    isDrawingNameValid(name: string, level: "Symbol" | "Block" | "Layer"): string | undefined;
+    /**
+     * Resolve Block definition, the input might be a string, or a string list
+     * @param name Name of the Block
+     * @param value Presentation to resolve the Block
+     * @returns Error message
+     */
+    resolveBlock(name: string, value: string | string[]): string[];
+    /**
+     * Resolve Layer definition, the input might be a string, or a string list
+     * @param name Name of the Layer
+     * @param value Presentation to resolve the Layer
+     * @returns Error message
+     */
+    resolveLayer(name: string, value: string | string[]): string[];
+    resolveViewBoxFromDef(def: string): ISvgBBox | string | undefined;
+    tryViewBox(def: string): ISvgBBox | string | undefined;
+    trySize(def: string): ISvgPoint | string | undefined;
+    resolveJobDrawingItem(draw: string, allowedTypes: string[]): IHuatuFinalDraw | ISvgBBox | ISvgPoint | string | undefined;
+    /**
+     * Resolve the defined job(s) from YML design file, 'draw' is one of the jobs
+     * @param jobName Name of the job, if it is 'draw', then the default global draw
+     * @param def The drawing design string to compose the final draw/job
+     * @returns Errors if any
+     */
+    resolveJob(jobName: string, def: string | string[] | IHuatuYmlJob | undefined): string[];
+    buildSvg(buildType: SvgBuildType, jobName?: string | undefined, withSize?: boolean): string;
+    buildSvgAsHtml(buildType: SvgBuildType, jobName?: string, indent?: boolean | undefined, withSize?: boolean): string;
+    buildSvgStandalone(buildType: SvgBuildType, jobName?: string | undefined, indent?: boolean | undefined, withSize?: boolean): string;
+    /** --------------- Component part ------------------------------------------------------------------------------ */
+    resolveComponentDef(name: string, def: string | IHuatuYmlObj): string[];
+    resolveComponentPlacement(name: string, def: string | IHuatuYmlObj): string[];
+    parseComponentPorts(obj: IHuatuYmlObj): string[];
+    /** --------------- Static Methods ------------------------------------------------------------------------------ */
+    static tryDesc(def: string): string | undefined;
+    static resolveConfig(cfg: IHuatuConfigInYml): IHuatuConfig;
+    static buildEmbeddedStyles(): string;
+    static RESERVED_NAMES: string[];
+}
+
+declare const renderWtHuatuYml: (yml: string) => Promise<string>;
+interface IWtHuatuComponentPreviewOptions {
+    mirror?: HuatuComponentPlacementMirrorType;
+    rotDeg?: number;
+    rotateLabel?: boolean;
+    showMarks?: boolean;
+    ignoreConfig?: boolean;
+}
+interface IWtHuatuRenderOptions {
+    job?: string | string[];
+    scale?: number;
+    outputFormat?: "html" | "svg";
+    componentPreview?: IWtHuatuComponentPreviewOptions;
+}
+interface IWtHuatuResolvingResult {
+    huatu?: WtHuatu;
+    errors: IHuatuResolvingError[];
+    warnings: string[];
+    infos: string[];
+}
+interface IWtHuatuRenderedJob {
+    jobName: string;
+    html: string;
+    width?: number;
+    height?: number;
+    scale?: number;
+}
+interface IWtHuatuRenderResult extends IWtHuatuResolvingResult {
+    inputYml: string;
+    ymlParseSucceeded: boolean;
+    ymlParsedObj?: IHuatuYmlObj;
+    type: "huatu" | "component" | "unknown";
+    rendered: IWtHuatuRenderedJob[];
+}
+declare const renderAComponent: (compObj: IHuatuYmlObj, opts?: IWtHuatuComponentPreviewOptions) => IWtHuatuResolvingResult;
+declare const renderYmlInput: (yml: string, opts: IWtHuatuRenderOptions) => Promise<IWtHuatuRenderResult>;
+
+export { type IWtHuatuComponentPreviewOptions, type IWtHuatuRenderOptions, type IWtHuatuRenderResult, type IWtHuatuRenderedJob, type IWtHuatuResolvingResult, WtHuatu, renderAComponent, renderWtHuatuYml, renderYmlInput };