ducjs 1.0.0

package/dist/flatbuffers/duc/dimension-ext-line-style.js

@@ -0,0 +1,57 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
+import * as flatbuffers from 'flatbuffers';
+import { ElementStroke } from '../duc/element-stroke';
+export class DimensionExtLineStyle {
+    constructor() {
+        this.bb = null;
+        this.bb_pos = 0;
+    }
+    __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+    }
+    static getRootAsDimensionExtLineStyle(bb, obj) {
+        return (obj || new DimensionExtLineStyle()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    }
+    static getSizePrefixedRootAsDimensionExtLineStyle(bb, obj) {
+        bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
+        return (obj || new DimensionExtLineStyle()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    }
+    stroke(obj) {
+        const offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? (obj || new ElementStroke()).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
+    }
+    overshoot() {
+        const offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? this.bb.readFloat64(this.bb_pos + offset) : 0.0;
+    }
+    offset() {
+        const offset = this.bb.__offset(this.bb_pos, 8);
+        return offset ? this.bb.readFloat64(this.bb_pos + offset) : 0.0;
+    }
+    static startDimensionExtLineStyle(builder) {
+        builder.startObject(3);
+    }
+    static addStroke(builder, strokeOffset) {
+        builder.addFieldOffset(0, strokeOffset, 0);
+    }
+    static addOvershoot(builder, overshoot) {
+        builder.addFieldFloat64(1, overshoot, 0.0);
+    }
+    static addOffset(builder, offset) {
+        builder.addFieldFloat64(2, offset, 0.0);
+    }
+    static endDimensionExtLineStyle(builder) {
+        const offset = builder.endObject();
+        return offset;
+    }
+    static createDimensionExtLineStyle(builder, strokeOffset, overshoot, offset) {
+        DimensionExtLineStyle.startDimensionExtLineStyle(builder);
+        DimensionExtLineStyle.addStroke(builder, strokeOffset);
+        DimensionExtLineStyle.addOvershoot(builder, overshoot);
+        DimensionExtLineStyle.addOffset(builder, offset);
+        return DimensionExtLineStyle.endDimensionExtLineStyle(builder);
+    }
+}

package/dist/flatbuffers/duc/dimension-fit-rule.d.ts

@@ -0,0 +1,6 @@
+export declare enum DIMENSION_FIT_RULE {
+    TEXT_AND_ARROWS = 10,
+    ARROWS_ONLY = 11,
+    TEXT_ONLY = 12,
+    BEST_FIT = 13
+}

package/dist/flatbuffers/duc/dimension-fit-rule.js

@@ -0,0 +1,9 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
+export var DIMENSION_FIT_RULE;
+(function (DIMENSION_FIT_RULE) {
+    DIMENSION_FIT_RULE[DIMENSION_FIT_RULE["TEXT_AND_ARROWS"] = 10] = "TEXT_AND_ARROWS";
+    DIMENSION_FIT_RULE[DIMENSION_FIT_RULE["ARROWS_ONLY"] = 11] = "ARROWS_ONLY";
+    DIMENSION_FIT_RULE[DIMENSION_FIT_RULE["TEXT_ONLY"] = 12] = "TEXT_ONLY";
+    DIMENSION_FIT_RULE[DIMENSION_FIT_RULE["BEST_FIT"] = 13] = "BEST_FIT";
+})(DIMENSION_FIT_RULE || (DIMENSION_FIT_RULE = {}));

package/dist/flatbuffers/duc/dimension-fit-style.d.ts

@@ -0,0 +1,19 @@
+import * as flatbuffers from 'flatbuffers';
+import { DIMENSION_FIT_RULE } from '../duc/dimension-fit-rule';
+import { DIMENSION_TEXT_PLACEMENT } from '../duc/dimension-text-placement';
+export declare class DimensionFitStyle {
+    bb: flatbuffers.ByteBuffer | null;
+    bb_pos: number;
+    __init(i: number, bb: flatbuffers.ByteBuffer): DimensionFitStyle;
+    static getRootAsDimensionFitStyle(bb: flatbuffers.ByteBuffer, obj?: DimensionFitStyle): DimensionFitStyle;
+    static getSizePrefixedRootAsDimensionFitStyle(bb: flatbuffers.ByteBuffer, obj?: DimensionFitStyle): DimensionFitStyle;
+    rule(): DIMENSION_FIT_RULE | null;
+    textPlacement(): DIMENSION_TEXT_PLACEMENT | null;
+    forceTextInside(): boolean;
+    static startDimensionFitStyle(builder: flatbuffers.Builder): void;
+    static addRule(builder: flatbuffers.Builder, rule: DIMENSION_FIT_RULE): void;
+    static addTextPlacement(builder: flatbuffers.Builder, textPlacement: DIMENSION_TEXT_PLACEMENT): void;
+    static addForceTextInside(builder: flatbuffers.Builder, forceTextInside: boolean): void;
+    static endDimensionFitStyle(builder: flatbuffers.Builder): flatbuffers.Offset;
+    static createDimensionFitStyle(builder: flatbuffers.Builder, rule: DIMENSION_FIT_RULE | null, textPlacement: DIMENSION_TEXT_PLACEMENT | null, forceTextInside: boolean): flatbuffers.Offset;
+}

package/dist/flatbuffers/duc/dimension-fit-style.js

@@ -0,0 +1,58 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
+import * as flatbuffers from 'flatbuffers';
+export class DimensionFitStyle {
+    constructor() {
+        this.bb = null;
+        this.bb_pos = 0;
+    }
+    __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+    }
+    static getRootAsDimensionFitStyle(bb, obj) {
+        return (obj || new DimensionFitStyle()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    }
+    static getSizePrefixedRootAsDimensionFitStyle(bb, obj) {
+        bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
+        return (obj || new DimensionFitStyle()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    }
+    rule() {
+        const offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? this.bb.readUint8(this.bb_pos + offset) : null;
+    }
+    textPlacement() {
+        const offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? this.bb.readUint8(this.bb_pos + offset) : null;
+    }
+    forceTextInside() {
+        const offset = this.bb.__offset(this.bb_pos, 8);
+        return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false;
+    }
+    static startDimensionFitStyle(builder) {
+        builder.startObject(3);
+    }
+    static addRule(builder, rule) {
+        builder.addFieldInt8(0, rule, null);
+    }
+    static addTextPlacement(builder, textPlacement) {
+        builder.addFieldInt8(1, textPlacement, null);
+    }
+    static addForceTextInside(builder, forceTextInside) {
+        builder.addFieldInt8(2, +forceTextInside, +false);
+    }
+    static endDimensionFitStyle(builder) {
+        const offset = builder.endObject();
+        return offset;
+    }
+    static createDimensionFitStyle(builder, rule, textPlacement, forceTextInside) {
+        DimensionFitStyle.startDimensionFitStyle(builder);
+        if (rule !== null)
+            DimensionFitStyle.addRule(builder, rule);
+        if (textPlacement !== null)
+            DimensionFitStyle.addTextPlacement(builder, textPlacement);
+        DimensionFitStyle.addForceTextInside(builder, forceTextInside);
+        return DimensionFitStyle.endDimensionFitStyle(builder);
+    }
+}

package/dist/flatbuffers/duc/dimension-line-style.d.ts

@@ -0,0 +1,16 @@
+import * as flatbuffers from 'flatbuffers';
+import { ElementStroke } from '../duc/element-stroke';
+export declare class DimensionLineStyle {
+    bb: flatbuffers.ByteBuffer | null;
+    bb_pos: number;
+    __init(i: number, bb: flatbuffers.ByteBuffer): DimensionLineStyle;
+    static getRootAsDimensionLineStyle(bb: flatbuffers.ByteBuffer, obj?: DimensionLineStyle): DimensionLineStyle;
+    static getSizePrefixedRootAsDimensionLineStyle(bb: flatbuffers.ByteBuffer, obj?: DimensionLineStyle): DimensionLineStyle;
+    stroke(obj?: ElementStroke): ElementStroke | null;
+    textGap(): number;
+    static startDimensionLineStyle(builder: flatbuffers.Builder): void;
+    static addStroke(builder: flatbuffers.Builder, strokeOffset: flatbuffers.Offset): void;
+    static addTextGap(builder: flatbuffers.Builder, textGap: number): void;
+    static endDimensionLineStyle(builder: flatbuffers.Builder): flatbuffers.Offset;
+    static createDimensionLineStyle(builder: flatbuffers.Builder, strokeOffset: flatbuffers.Offset, textGap: number): flatbuffers.Offset;
+}

package/dist/flatbuffers/duc/dimension-line-style.js

@@ -0,0 +1,49 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
+import * as flatbuffers from 'flatbuffers';
+import { ElementStroke } from '../duc/element-stroke';
+export class DimensionLineStyle {
+    constructor() {
+        this.bb = null;
+        this.bb_pos = 0;
+    }
+    __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+    }
+    static getRootAsDimensionLineStyle(bb, obj) {
+        return (obj || new DimensionLineStyle()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    }
+    static getSizePrefixedRootAsDimensionLineStyle(bb, obj) {
+        bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
+        return (obj || new DimensionLineStyle()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    }
+    stroke(obj) {
+        const offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? (obj || new ElementStroke()).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
+    }
+    textGap() {
+        const offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? this.bb.readFloat64(this.bb_pos + offset) : 0.0;
+    }
+    static startDimensionLineStyle(builder) {
+        builder.startObject(2);
+    }
+    static addStroke(builder, strokeOffset) {
+        builder.addFieldOffset(0, strokeOffset, 0);
+    }
+    static addTextGap(builder, textGap) {
+        builder.addFieldFloat64(1, textGap, 0.0);
+    }
+    static endDimensionLineStyle(builder) {
+        const offset = builder.endObject();
+        return offset;
+    }
+    static createDimensionLineStyle(builder, strokeOffset, textGap) {
+        DimensionLineStyle.startDimensionLineStyle(builder);
+        DimensionLineStyle.addStroke(builder, strokeOffset);
+        DimensionLineStyle.addTextGap(builder, textGap);
+        return DimensionLineStyle.endDimensionLineStyle(builder);
+    }
+}

package/dist/flatbuffers/duc/dimension-symbol-style.d.ts

@@ -0,0 +1,22 @@
+import * as flatbuffers from 'flatbuffers';
+import { DucHead } from '../duc/duc-head';
+import { MARK_ELLIPSE_CENTER } from '../duc/mark-ellipse-center';
+export declare class DimensionSymbolStyle {
+    bb: flatbuffers.ByteBuffer | null;
+    bb_pos: number;
+    __init(i: number, bb: flatbuffers.ByteBuffer): DimensionSymbolStyle;
+    static getRootAsDimensionSymbolStyle(bb: flatbuffers.ByteBuffer, obj?: DimensionSymbolStyle): DimensionSymbolStyle;
+    static getSizePrefixedRootAsDimensionSymbolStyle(bb: flatbuffers.ByteBuffer, obj?: DimensionSymbolStyle): DimensionSymbolStyle;
+    headsOverride(index: number, obj?: DucHead): DucHead | null;
+    headsOverrideLength(): number;
+    centerMarkType(): MARK_ELLIPSE_CENTER | null;
+    centerMarkSize(): number;
+    static startDimensionSymbolStyle(builder: flatbuffers.Builder): void;
+    static addHeadsOverride(builder: flatbuffers.Builder, headsOverrideOffset: flatbuffers.Offset): void;
+    static createHeadsOverrideVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset;
+    static startHeadsOverrideVector(builder: flatbuffers.Builder, numElems: number): void;
+    static addCenterMarkType(builder: flatbuffers.Builder, centerMarkType: MARK_ELLIPSE_CENTER): void;
+    static addCenterMarkSize(builder: flatbuffers.Builder, centerMarkSize: number): void;
+    static endDimensionSymbolStyle(builder: flatbuffers.Builder): flatbuffers.Offset;
+    static createDimensionSymbolStyle(builder: flatbuffers.Builder, headsOverrideOffset: flatbuffers.Offset, centerMarkType: MARK_ELLIPSE_CENTER | null, centerMarkSize: number): flatbuffers.Offset;
+}

package/dist/flatbuffers/duc/dimension-symbol-style.js

@@ -0,0 +1,72 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
+import * as flatbuffers from 'flatbuffers';
+import { DucHead } from '../duc/duc-head';
+export class DimensionSymbolStyle {
+    constructor() {
+        this.bb = null;
+        this.bb_pos = 0;
+    }
+    __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+    }
+    static getRootAsDimensionSymbolStyle(bb, obj) {
+        return (obj || new DimensionSymbolStyle()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    }
+    static getSizePrefixedRootAsDimensionSymbolStyle(bb, obj) {
+        bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
+        return (obj || new DimensionSymbolStyle()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    }
+    headsOverride(index, obj) {
+        const offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? (obj || new DucHead()).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null;
+    }
+    headsOverrideLength() {
+        const offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+    }
+    centerMarkType() {
+        const offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? this.bb.readUint8(this.bb_pos + offset) : null;
+    }
+    centerMarkSize() {
+        const offset = this.bb.__offset(this.bb_pos, 8);
+        return offset ? this.bb.readFloat64(this.bb_pos + offset) : 0.0;
+    }
+    static startDimensionSymbolStyle(builder) {
+        builder.startObject(3);
+    }
+    static addHeadsOverride(builder, headsOverrideOffset) {
+        builder.addFieldOffset(0, headsOverrideOffset, 0);
+    }
+    static createHeadsOverrideVector(builder, data) {
+        builder.startVector(4, data.length, 4);
+        for (let i = data.length - 1; i >= 0; i--) {
+            builder.addOffset(data[i]);
+        }
+        return builder.endVector();
+    }
+    static startHeadsOverrideVector(builder, numElems) {
+        builder.startVector(4, numElems, 4);
+    }
+    static addCenterMarkType(builder, centerMarkType) {
+        builder.addFieldInt8(1, centerMarkType, null);
+    }
+    static addCenterMarkSize(builder, centerMarkSize) {
+        builder.addFieldFloat64(2, centerMarkSize, 0.0);
+    }
+    static endDimensionSymbolStyle(builder) {
+        const offset = builder.endObject();
+        return offset;
+    }
+    static createDimensionSymbolStyle(builder, headsOverrideOffset, centerMarkType, centerMarkSize) {
+        DimensionSymbolStyle.startDimensionSymbolStyle(builder);
+        DimensionSymbolStyle.addHeadsOverride(builder, headsOverrideOffset);
+        if (centerMarkType !== null)
+            DimensionSymbolStyle.addCenterMarkType(builder, centerMarkType);
+        DimensionSymbolStyle.addCenterMarkSize(builder, centerMarkSize);
+        return DimensionSymbolStyle.endDimensionSymbolStyle(builder);
+    }
+}

package/dist/flatbuffers/duc/dimension-text-placement.d.ts

@@ -0,0 +1,5 @@
+export declare enum DIMENSION_TEXT_PLACEMENT {
+    BESIDE_LINE = 10,
+    OVER_LINE = 11,
+    OVER_LINE_WITH_LEADER = 12
+}

package/dist/flatbuffers/duc/dimension-text-placement.js

@@ -0,0 +1,8 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
+export var DIMENSION_TEXT_PLACEMENT;
+(function (DIMENSION_TEXT_PLACEMENT) {
+    DIMENSION_TEXT_PLACEMENT[DIMENSION_TEXT_PLACEMENT["BESIDE_LINE"] = 10] = "BESIDE_LINE";
+    DIMENSION_TEXT_PLACEMENT[DIMENSION_TEXT_PLACEMENT["OVER_LINE"] = 11] = "OVER_LINE";
+    DIMENSION_TEXT_PLACEMENT[DIMENSION_TEXT_PLACEMENT["OVER_LINE_WITH_LEADER"] = 12] = "OVER_LINE_WITH_LEADER";
+})(DIMENSION_TEXT_PLACEMENT || (DIMENSION_TEXT_PLACEMENT = {}));

package/dist/flatbuffers/duc/dimension-tolerance-style.d.ts

@@ -0,0 +1,24 @@
+import * as flatbuffers from 'flatbuffers';
+import { DucTextStyle } from '../duc/duc-text-style';
+import { TOLERANCE_DISPLAY } from '../duc/tolerance-display';
+export declare class DimensionToleranceStyle {
+    bb: flatbuffers.ByteBuffer | null;
+    bb_pos: number;
+    __init(i: number, bb: flatbuffers.ByteBuffer): DimensionToleranceStyle;
+    static getRootAsDimensionToleranceStyle(bb: flatbuffers.ByteBuffer, obj?: DimensionToleranceStyle): DimensionToleranceStyle;
+    static getSizePrefixedRootAsDimensionToleranceStyle(bb: flatbuffers.ByteBuffer, obj?: DimensionToleranceStyle): DimensionToleranceStyle;
+    enabled(): boolean;
+    displayMethod(): TOLERANCE_DISPLAY | null;
+    upperValue(): number;
+    lowerValue(): number;
+    precision(): number;
+    textStyle(obj?: DucTextStyle): DucTextStyle | null;
+    static startDimensionToleranceStyle(builder: flatbuffers.Builder): void;
+    static addEnabled(builder: flatbuffers.Builder, enabled: boolean): void;
+    static addDisplayMethod(builder: flatbuffers.Builder, displayMethod: TOLERANCE_DISPLAY): void;
+    static addUpperValue(builder: flatbuffers.Builder, upperValue: number): void;
+    static addLowerValue(builder: flatbuffers.Builder, lowerValue: number): void;
+    static addPrecision(builder: flatbuffers.Builder, precision: number): void;
+    static addTextStyle(builder: flatbuffers.Builder, textStyleOffset: flatbuffers.Offset): void;
+    static endDimensionToleranceStyle(builder: flatbuffers.Builder): flatbuffers.Offset;
+}

package/dist/flatbuffers/duc/dimension-tolerance-style.js

@@ -0,0 +1,71 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
+import * as flatbuffers from 'flatbuffers';
+import { DucTextStyle } from '../duc/duc-text-style';
+export class DimensionToleranceStyle {
+    constructor() {
+        this.bb = null;
+        this.bb_pos = 0;
+    }
+    __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+    }
+    static getRootAsDimensionToleranceStyle(bb, obj) {
+        return (obj || new DimensionToleranceStyle()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    }
+    static getSizePrefixedRootAsDimensionToleranceStyle(bb, obj) {
+        bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
+        return (obj || new DimensionToleranceStyle()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    }
+    enabled() {
+        const offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false;
+    }
+    displayMethod() {
+        const offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? this.bb.readUint8(this.bb_pos + offset) : null;
+    }
+    upperValue() {
+        const offset = this.bb.__offset(this.bb_pos, 8);
+        return offset ? this.bb.readFloat64(this.bb_pos + offset) : 0.0;
+    }
+    lowerValue() {
+        const offset = this.bb.__offset(this.bb_pos, 10);
+        return offset ? this.bb.readFloat64(this.bb_pos + offset) : 0.0;
+    }
+    precision() {
+        const offset = this.bb.__offset(this.bb_pos, 12);
+        return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
+    }
+    textStyle(obj) {
+        const offset = this.bb.__offset(this.bb_pos, 14);
+        return offset ? (obj || new DucTextStyle()).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
+    }
+    static startDimensionToleranceStyle(builder) {
+        builder.startObject(6);
+    }
+    static addEnabled(builder, enabled) {
+        builder.addFieldInt8(0, +enabled, +false);
+    }
+    static addDisplayMethod(builder, displayMethod) {
+        builder.addFieldInt8(1, displayMethod, null);
+    }
+    static addUpperValue(builder, upperValue) {
+        builder.addFieldFloat64(2, upperValue, 0.0);
+    }
+    static addLowerValue(builder, lowerValue) {
+        builder.addFieldFloat64(3, lowerValue, 0.0);
+    }
+    static addPrecision(builder, precision) {
+        builder.addFieldInt32(4, precision, 0);
+    }
+    static addTextStyle(builder, textStyleOffset) {
+        builder.addFieldOffset(5, textStyleOffset, 0);
+    }
+    static endDimensionToleranceStyle(builder) {
+        const offset = builder.endObject();
+        return offset;
+    }
+}

package/dist/flatbuffers/duc/dimension-type.d.ts

@@ -0,0 +1,15 @@
+export declare enum DIMENSION_TYPE {
+    LINEAR = 10,
+    ALIGNED = 11,
+    ANGULAR = 12,
+    ARC_LENGTH = 13,
+    RADIUS = 14,
+    DIAMETER = 15,
+    CENTER_MARK = 16,
+    ROTATED = 17,
+    SPACING = 18,
+    CONTINUE = 19,
+    BASELINE = 20,
+    JOGGED_LINEAR = 21,
+    ORDINATE = 22
+}

package/dist/flatbuffers/duc/dimension-type.js

@@ -0,0 +1,18 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
+export var DIMENSION_TYPE;
+(function (DIMENSION_TYPE) {
+    DIMENSION_TYPE[DIMENSION_TYPE["LINEAR"] = 10] = "LINEAR";
+    DIMENSION_TYPE[DIMENSION_TYPE["ALIGNED"] = 11] = "ALIGNED";
+    DIMENSION_TYPE[DIMENSION_TYPE["ANGULAR"] = 12] = "ANGULAR";
+    DIMENSION_TYPE[DIMENSION_TYPE["ARC_LENGTH"] = 13] = "ARC_LENGTH";
+    DIMENSION_TYPE[DIMENSION_TYPE["RADIUS"] = 14] = "RADIUS";
+    DIMENSION_TYPE[DIMENSION_TYPE["DIAMETER"] = 15] = "DIAMETER";
+    DIMENSION_TYPE[DIMENSION_TYPE["CENTER_MARK"] = 16] = "CENTER_MARK";
+    DIMENSION_TYPE[DIMENSION_TYPE["ROTATED"] = 17] = "ROTATED";
+    DIMENSION_TYPE[DIMENSION_TYPE["SPACING"] = 18] = "SPACING";
+    DIMENSION_TYPE[DIMENSION_TYPE["CONTINUE"] = 19] = "CONTINUE";
+    DIMENSION_TYPE[DIMENSION_TYPE["BASELINE"] = 20] = "BASELINE";
+    DIMENSION_TYPE[DIMENSION_TYPE["JOGGED_LINEAR"] = 21] = "JOGGED_LINEAR";
+    DIMENSION_TYPE[DIMENSION_TYPE["ORDINATE"] = 22] = "ORDINATE";
+})(DIMENSION_TYPE || (DIMENSION_TYPE = {}));

package/dist/flatbuffers/duc/dimension-units-format.d.ts

@@ -0,0 +1,7 @@
+export declare enum DIMENSION_UNITS_FORMAT {
+    DECIMAL = 10,
+    ENGINEERING = 11,
+    ARCHITECTURAL = 12,
+    FRACTIONAL = 13,
+    SCIENTIFIC = 14
+}

package/dist/flatbuffers/duc/dimension-units-format.js

@@ -0,0 +1,10 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
+export var DIMENSION_UNITS_FORMAT;
+(function (DIMENSION_UNITS_FORMAT) {
+    DIMENSION_UNITS_FORMAT[DIMENSION_UNITS_FORMAT["DECIMAL"] = 10] = "DECIMAL";
+    DIMENSION_UNITS_FORMAT[DIMENSION_UNITS_FORMAT["ENGINEERING"] = 11] = "ENGINEERING";
+    DIMENSION_UNITS_FORMAT[DIMENSION_UNITS_FORMAT["ARCHITECTURAL"] = 12] = "ARCHITECTURAL";
+    DIMENSION_UNITS_FORMAT[DIMENSION_UNITS_FORMAT["FRACTIONAL"] = 13] = "FRACTIONAL";
+    DIMENSION_UNITS_FORMAT[DIMENSION_UNITS_FORMAT["SCIENTIFIC"] = 14] = "SCIENTIFIC";
+})(DIMENSION_UNITS_FORMAT || (DIMENSION_UNITS_FORMAT = {}));

package/dist/flatbuffers/duc/dimension-validation-rules.d.ts

@@ -0,0 +1,25 @@
+import * as flatbuffers from 'flatbuffers';
+export declare class DimensionValidationRules {
+    bb: flatbuffers.ByteBuffer | null;
+    bb_pos: number;
+    __init(i: number, bb: flatbuffers.ByteBuffer): DimensionValidationRules;
+    static getRootAsDimensionValidationRules(bb: flatbuffers.ByteBuffer, obj?: DimensionValidationRules): DimensionValidationRules;
+    static getSizePrefixedRootAsDimensionValidationRules(bb: flatbuffers.ByteBuffer, obj?: DimensionValidationRules): DimensionValidationRules;
+    minTextHeight(): number;
+    maxTextHeight(): number;
+    allowedPrecisions(index: number): number | null;
+    allowedPrecisionsLength(): number;
+    allowedPrecisionsArray(): Int32Array | null;
+    static startDimensionValidationRules(builder: flatbuffers.Builder): void;
+    static addMinTextHeight(builder: flatbuffers.Builder, minTextHeight: number): void;
+    static addMaxTextHeight(builder: flatbuffers.Builder, maxTextHeight: number): void;
+    static addAllowedPrecisions(builder: flatbuffers.Builder, allowedPrecisionsOffset: flatbuffers.Offset): void;
+    static createAllowedPrecisionsVector(builder: flatbuffers.Builder, data: number[] | Int32Array): flatbuffers.Offset;
+    /**
+     * @deprecated This Uint8Array overload will be removed in the future.
+     */
+    static createAllowedPrecisionsVector(builder: flatbuffers.Builder, data: number[] | Uint8Array): flatbuffers.Offset;
+    static startAllowedPrecisionsVector(builder: flatbuffers.Builder, numElems: number): void;
+    static endDimensionValidationRules(builder: flatbuffers.Builder): flatbuffers.Offset;
+    static createDimensionValidationRules(builder: flatbuffers.Builder, minTextHeight: number, maxTextHeight: number, allowedPrecisionsOffset: flatbuffers.Offset): flatbuffers.Offset;
+}

package/dist/flatbuffers/duc/dimension-validation-rules.js

@@ -0,0 +1,74 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
+import * as flatbuffers from 'flatbuffers';
+export class DimensionValidationRules {
+    constructor() {
+        this.bb = null;
+        this.bb_pos = 0;
+    }
+    __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+    }
+    static getRootAsDimensionValidationRules(bb, obj) {
+        return (obj || new DimensionValidationRules()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    }
+    static getSizePrefixedRootAsDimensionValidationRules(bb, obj) {
+        bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
+        return (obj || new DimensionValidationRules()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    }
+    minTextHeight() {
+        const offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? this.bb.readFloat64(this.bb_pos + offset) : 0.0;
+    }
+    maxTextHeight() {
+        const offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? this.bb.readFloat64(this.bb_pos + offset) : 0.0;
+    }
+    allowedPrecisions(index) {
+        const offset = this.bb.__offset(this.bb_pos, 8);
+        return offset ? this.bb.readInt32(this.bb.__vector(this.bb_pos + offset) + index * 4) : 0;
+    }
+    allowedPrecisionsLength() {
+        const offset = this.bb.__offset(this.bb_pos, 8);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+    }
+    allowedPrecisionsArray() {
+        const offset = this.bb.__offset(this.bb_pos, 8);
+        return offset ? new Int32Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
+    }
+    static startDimensionValidationRules(builder) {
+        builder.startObject(3);
+    }
+    static addMinTextHeight(builder, minTextHeight) {
+        builder.addFieldFloat64(0, minTextHeight, 0.0);
+    }
+    static addMaxTextHeight(builder, maxTextHeight) {
+        builder.addFieldFloat64(1, maxTextHeight, 0.0);
+    }
+    static addAllowedPrecisions(builder, allowedPrecisionsOffset) {
+        builder.addFieldOffset(2, allowedPrecisionsOffset, 0);
+    }
+    static createAllowedPrecisionsVector(builder, data) {
+        builder.startVector(4, data.length, 4);
+        for (let i = data.length - 1; i >= 0; i--) {
+            builder.addInt32(data[i]);
+        }
+        return builder.endVector();
+    }
+    static startAllowedPrecisionsVector(builder, numElems) {
+        builder.startVector(4, numElems, 4);
+    }
+    static endDimensionValidationRules(builder) {
+        const offset = builder.endObject();
+        return offset;
+    }
+    static createDimensionValidationRules(builder, minTextHeight, maxTextHeight, allowedPrecisionsOffset) {
+        DimensionValidationRules.startDimensionValidationRules(builder);
+        DimensionValidationRules.addMinTextHeight(builder, minTextHeight);
+        DimensionValidationRules.addMaxTextHeight(builder, maxTextHeight);
+        DimensionValidationRules.addAllowedPrecisions(builder, allowedPrecisionsOffset);
+        return DimensionValidationRules.endDimensionValidationRules(builder);
+    }
+}

package/dist/flatbuffers/duc/duc-arrow-element.d.ts

@@ -0,0 +1,16 @@
+import * as flatbuffers from 'flatbuffers';
+import { _DucLinearElementBase } from '../duc/duc-linear-element-base';
+export declare class DucArrowElement {
+    bb: flatbuffers.ByteBuffer | null;
+    bb_pos: number;
+    __init(i: number, bb: flatbuffers.ByteBuffer): DucArrowElement;
+    static getRootAsDucArrowElement(bb: flatbuffers.ByteBuffer, obj?: DucArrowElement): DucArrowElement;
+    static getSizePrefixedRootAsDucArrowElement(bb: flatbuffers.ByteBuffer, obj?: DucArrowElement): DucArrowElement;
+    linearBase(obj?: _DucLinearElementBase): _DucLinearElementBase | null;
+    elbowed(): boolean;
+    static startDucArrowElement(builder: flatbuffers.Builder): void;
+    static addLinearBase(builder: flatbuffers.Builder, linearBaseOffset: flatbuffers.Offset): void;
+    static addElbowed(builder: flatbuffers.Builder, elbowed: boolean): void;
+    static endDucArrowElement(builder: flatbuffers.Builder): flatbuffers.Offset;
+    static createDucArrowElement(builder: flatbuffers.Builder, linearBaseOffset: flatbuffers.Offset, elbowed: boolean): flatbuffers.Offset;
+}

package/dist/flatbuffers/duc/duc-arrow-element.js

@@ -0,0 +1,49 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
+import * as flatbuffers from 'flatbuffers';
+import { _DucLinearElementBase } from '../duc/duc-linear-element-base';
+export class DucArrowElement {
+    constructor() {
+        this.bb = null;
+        this.bb_pos = 0;
+    }
+    __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+    }
+    static getRootAsDucArrowElement(bb, obj) {
+        return (obj || new DucArrowElement()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    }
+    static getSizePrefixedRootAsDucArrowElement(bb, obj) {
+        bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
+        return (obj || new DucArrowElement()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    }
+    linearBase(obj) {
+        const offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? (obj || new _DucLinearElementBase()).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
+    }
+    elbowed() {
+        const offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false;
+    }
+    static startDucArrowElement(builder) {
+        builder.startObject(2);
+    }
+    static addLinearBase(builder, linearBaseOffset) {
+        builder.addFieldOffset(0, linearBaseOffset, 0);
+    }
+    static addElbowed(builder, elbowed) {
+        builder.addFieldInt8(1, +elbowed, +false);
+    }
+    static endDucArrowElement(builder) {
+        const offset = builder.endObject();
+        return offset;
+    }
+    static createDucArrowElement(builder, linearBaseOffset, elbowed) {
+        DucArrowElement.startDucArrowElement(builder);
+        DucArrowElement.addLinearBase(builder, linearBaseOffset);
+        DucArrowElement.addElbowed(builder, elbowed);
+        return DucArrowElement.endDucArrowElement(builder);
+    }
+}