ducjs 1.0.0

package/dist/flatbuffers/duc/standard-styles.d.ts

@@ -0,0 +1,77 @@
+import * as flatbuffers from 'flatbuffers';
+import { IdentifiedCommonStyle } from '../duc/identified-common-style';
+import { IdentifiedDimensionStyle } from '../duc/identified-dimension-style';
+import { IdentifiedDocStyle } from '../duc/identified-doc-style';
+import { IdentifiedFCFStyle } from '../duc/identified-fcfstyle';
+import { IdentifiedHatchStyle } from '../duc/identified-hatch-style';
+import { IdentifiedLeaderStyle } from '../duc/identified-leader-style';
+import { IdentifiedStackLikeStyle } from '../duc/identified-stack-like-style';
+import { IdentifiedTableStyle } from '../duc/identified-table-style';
+import { IdentifiedTextStyle } from '../duc/identified-text-style';
+import { IdentifiedViewportStyle } from '../duc/identified-viewport-style';
+import { IdentifiedXRayStyle } from '../duc/identified-xray-style';
+export declare class StandardStyles {
+    bb: flatbuffers.ByteBuffer | null;
+    bb_pos: number;
+    __init(i: number, bb: flatbuffers.ByteBuffer): StandardStyles;
+    static getRootAsStandardStyles(bb: flatbuffers.ByteBuffer, obj?: StandardStyles): StandardStyles;
+    static getSizePrefixedRootAsStandardStyles(bb: flatbuffers.ByteBuffer, obj?: StandardStyles): StandardStyles;
+    commonStyles(index: number, obj?: IdentifiedCommonStyle): IdentifiedCommonStyle | null;
+    commonStylesLength(): number;
+    stackLikeStyles(index: number, obj?: IdentifiedStackLikeStyle): IdentifiedStackLikeStyle | null;
+    stackLikeStylesLength(): number;
+    textStyles(index: number, obj?: IdentifiedTextStyle): IdentifiedTextStyle | null;
+    textStylesLength(): number;
+    dimensionStyles(index: number, obj?: IdentifiedDimensionStyle): IdentifiedDimensionStyle | null;
+    dimensionStylesLength(): number;
+    leaderStyles(index: number, obj?: IdentifiedLeaderStyle): IdentifiedLeaderStyle | null;
+    leaderStylesLength(): number;
+    featureControlFrameStyles(index: number, obj?: IdentifiedFCFStyle): IdentifiedFCFStyle | null;
+    featureControlFrameStylesLength(): number;
+    tableStyles(index: number, obj?: IdentifiedTableStyle): IdentifiedTableStyle | null;
+    tableStylesLength(): number;
+    docStyles(index: number, obj?: IdentifiedDocStyle): IdentifiedDocStyle | null;
+    docStylesLength(): number;
+    viewportStyles(index: number, obj?: IdentifiedViewportStyle): IdentifiedViewportStyle | null;
+    viewportStylesLength(): number;
+    hatchStyles(index: number, obj?: IdentifiedHatchStyle): IdentifiedHatchStyle | null;
+    hatchStylesLength(): number;
+    xrayStyles(index: number, obj?: IdentifiedXRayStyle): IdentifiedXRayStyle | null;
+    xrayStylesLength(): number;
+    static startStandardStyles(builder: flatbuffers.Builder): void;
+    static addCommonStyles(builder: flatbuffers.Builder, commonStylesOffset: flatbuffers.Offset): void;
+    static createCommonStylesVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset;
+    static startCommonStylesVector(builder: flatbuffers.Builder, numElems: number): void;
+    static addStackLikeStyles(builder: flatbuffers.Builder, stackLikeStylesOffset: flatbuffers.Offset): void;
+    static createStackLikeStylesVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset;
+    static startStackLikeStylesVector(builder: flatbuffers.Builder, numElems: number): void;
+    static addTextStyles(builder: flatbuffers.Builder, textStylesOffset: flatbuffers.Offset): void;
+    static createTextStylesVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset;
+    static startTextStylesVector(builder: flatbuffers.Builder, numElems: number): void;
+    static addDimensionStyles(builder: flatbuffers.Builder, dimensionStylesOffset: flatbuffers.Offset): void;
+    static createDimensionStylesVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset;
+    static startDimensionStylesVector(builder: flatbuffers.Builder, numElems: number): void;
+    static addLeaderStyles(builder: flatbuffers.Builder, leaderStylesOffset: flatbuffers.Offset): void;
+    static createLeaderStylesVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset;
+    static startLeaderStylesVector(builder: flatbuffers.Builder, numElems: number): void;
+    static addFeatureControlFrameStyles(builder: flatbuffers.Builder, featureControlFrameStylesOffset: flatbuffers.Offset): void;
+    static createFeatureControlFrameStylesVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset;
+    static startFeatureControlFrameStylesVector(builder: flatbuffers.Builder, numElems: number): void;
+    static addTableStyles(builder: flatbuffers.Builder, tableStylesOffset: flatbuffers.Offset): void;
+    static createTableStylesVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset;
+    static startTableStylesVector(builder: flatbuffers.Builder, numElems: number): void;
+    static addDocStyles(builder: flatbuffers.Builder, docStylesOffset: flatbuffers.Offset): void;
+    static createDocStylesVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset;
+    static startDocStylesVector(builder: flatbuffers.Builder, numElems: number): void;
+    static addViewportStyles(builder: flatbuffers.Builder, viewportStylesOffset: flatbuffers.Offset): void;
+    static createViewportStylesVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset;
+    static startViewportStylesVector(builder: flatbuffers.Builder, numElems: number): void;
+    static addHatchStyles(builder: flatbuffers.Builder, hatchStylesOffset: flatbuffers.Offset): void;
+    static createHatchStylesVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset;
+    static startHatchStylesVector(builder: flatbuffers.Builder, numElems: number): void;
+    static addXrayStyles(builder: flatbuffers.Builder, xrayStylesOffset: flatbuffers.Offset): void;
+    static createXrayStylesVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset;
+    static startXrayStylesVector(builder: flatbuffers.Builder, numElems: number): void;
+    static endStandardStyles(builder: flatbuffers.Builder): flatbuffers.Offset;
+    static createStandardStyles(builder: flatbuffers.Builder, commonStylesOffset: flatbuffers.Offset, stackLikeStylesOffset: flatbuffers.Offset, textStylesOffset: flatbuffers.Offset, dimensionStylesOffset: flatbuffers.Offset, leaderStylesOffset: flatbuffers.Offset, featureControlFrameStylesOffset: flatbuffers.Offset, tableStylesOffset: flatbuffers.Offset, docStylesOffset: flatbuffers.Offset, viewportStylesOffset: flatbuffers.Offset, hatchStylesOffset: flatbuffers.Offset, xrayStylesOffset: flatbuffers.Offset): flatbuffers.Offset;
+}

package/dist/flatbuffers/duc/standard-styles.js

@@ -0,0 +1,285 @@
+// 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 { IdentifiedCommonStyle } from '../duc/identified-common-style';
+import { IdentifiedDimensionStyle } from '../duc/identified-dimension-style';
+import { IdentifiedDocStyle } from '../duc/identified-doc-style';
+import { IdentifiedFCFStyle } from '../duc/identified-fcfstyle';
+import { IdentifiedHatchStyle } from '../duc/identified-hatch-style';
+import { IdentifiedLeaderStyle } from '../duc/identified-leader-style';
+import { IdentifiedStackLikeStyle } from '../duc/identified-stack-like-style';
+import { IdentifiedTableStyle } from '../duc/identified-table-style';
+import { IdentifiedTextStyle } from '../duc/identified-text-style';
+import { IdentifiedViewportStyle } from '../duc/identified-viewport-style';
+import { IdentifiedXRayStyle } from '../duc/identified-xray-style';
+export class StandardStyles {
+    constructor() {
+        this.bb = null;
+        this.bb_pos = 0;
+    }
+    __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+    }
+    static getRootAsStandardStyles(bb, obj) {
+        return (obj || new StandardStyles()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    }
+    static getSizePrefixedRootAsStandardStyles(bb, obj) {
+        bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
+        return (obj || new StandardStyles()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    }
+    commonStyles(index, obj) {
+        const offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? (obj || new IdentifiedCommonStyle()).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null;
+    }
+    commonStylesLength() {
+        const offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+    }
+    stackLikeStyles(index, obj) {
+        const offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? (obj || new IdentifiedStackLikeStyle()).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null;
+    }
+    stackLikeStylesLength() {
+        const offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+    }
+    textStyles(index, obj) {
+        const offset = this.bb.__offset(this.bb_pos, 8);
+        return offset ? (obj || new IdentifiedTextStyle()).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null;
+    }
+    textStylesLength() {
+        const offset = this.bb.__offset(this.bb_pos, 8);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+    }
+    dimensionStyles(index, obj) {
+        const offset = this.bb.__offset(this.bb_pos, 10);
+        return offset ? (obj || new IdentifiedDimensionStyle()).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null;
+    }
+    dimensionStylesLength() {
+        const offset = this.bb.__offset(this.bb_pos, 10);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+    }
+    leaderStyles(index, obj) {
+        const offset = this.bb.__offset(this.bb_pos, 12);
+        return offset ? (obj || new IdentifiedLeaderStyle()).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null;
+    }
+    leaderStylesLength() {
+        const offset = this.bb.__offset(this.bb_pos, 12);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+    }
+    featureControlFrameStyles(index, obj) {
+        const offset = this.bb.__offset(this.bb_pos, 14);
+        return offset ? (obj || new IdentifiedFCFStyle()).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null;
+    }
+    featureControlFrameStylesLength() {
+        const offset = this.bb.__offset(this.bb_pos, 14);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+    }
+    tableStyles(index, obj) {
+        const offset = this.bb.__offset(this.bb_pos, 16);
+        return offset ? (obj || new IdentifiedTableStyle()).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null;
+    }
+    tableStylesLength() {
+        const offset = this.bb.__offset(this.bb_pos, 16);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+    }
+    docStyles(index, obj) {
+        const offset = this.bb.__offset(this.bb_pos, 18);
+        return offset ? (obj || new IdentifiedDocStyle()).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null;
+    }
+    docStylesLength() {
+        const offset = this.bb.__offset(this.bb_pos, 18);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+    }
+    viewportStyles(index, obj) {
+        const offset = this.bb.__offset(this.bb_pos, 20);
+        return offset ? (obj || new IdentifiedViewportStyle()).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null;
+    }
+    viewportStylesLength() {
+        const offset = this.bb.__offset(this.bb_pos, 20);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+    }
+    hatchStyles(index, obj) {
+        const offset = this.bb.__offset(this.bb_pos, 22);
+        return offset ? (obj || new IdentifiedHatchStyle()).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null;
+    }
+    hatchStylesLength() {
+        const offset = this.bb.__offset(this.bb_pos, 22);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+    }
+    xrayStyles(index, obj) {
+        const offset = this.bb.__offset(this.bb_pos, 24);
+        return offset ? (obj || new IdentifiedXRayStyle()).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null;
+    }
+    xrayStylesLength() {
+        const offset = this.bb.__offset(this.bb_pos, 24);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+    }
+    static startStandardStyles(builder) {
+        builder.startObject(11);
+    }
+    static addCommonStyles(builder, commonStylesOffset) {
+        builder.addFieldOffset(0, commonStylesOffset, 0);
+    }
+    static createCommonStylesVector(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 startCommonStylesVector(builder, numElems) {
+        builder.startVector(4, numElems, 4);
+    }
+    static addStackLikeStyles(builder, stackLikeStylesOffset) {
+        builder.addFieldOffset(1, stackLikeStylesOffset, 0);
+    }
+    static createStackLikeStylesVector(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 startStackLikeStylesVector(builder, numElems) {
+        builder.startVector(4, numElems, 4);
+    }
+    static addTextStyles(builder, textStylesOffset) {
+        builder.addFieldOffset(2, textStylesOffset, 0);
+    }
+    static createTextStylesVector(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 startTextStylesVector(builder, numElems) {
+        builder.startVector(4, numElems, 4);
+    }
+    static addDimensionStyles(builder, dimensionStylesOffset) {
+        builder.addFieldOffset(3, dimensionStylesOffset, 0);
+    }
+    static createDimensionStylesVector(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 startDimensionStylesVector(builder, numElems) {
+        builder.startVector(4, numElems, 4);
+    }
+    static addLeaderStyles(builder, leaderStylesOffset) {
+        builder.addFieldOffset(4, leaderStylesOffset, 0);
+    }
+    static createLeaderStylesVector(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 startLeaderStylesVector(builder, numElems) {
+        builder.startVector(4, numElems, 4);
+    }
+    static addFeatureControlFrameStyles(builder, featureControlFrameStylesOffset) {
+        builder.addFieldOffset(5, featureControlFrameStylesOffset, 0);
+    }
+    static createFeatureControlFrameStylesVector(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 startFeatureControlFrameStylesVector(builder, numElems) {
+        builder.startVector(4, numElems, 4);
+    }
+    static addTableStyles(builder, tableStylesOffset) {
+        builder.addFieldOffset(6, tableStylesOffset, 0);
+    }
+    static createTableStylesVector(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 startTableStylesVector(builder, numElems) {
+        builder.startVector(4, numElems, 4);
+    }
+    static addDocStyles(builder, docStylesOffset) {
+        builder.addFieldOffset(7, docStylesOffset, 0);
+    }
+    static createDocStylesVector(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 startDocStylesVector(builder, numElems) {
+        builder.startVector(4, numElems, 4);
+    }
+    static addViewportStyles(builder, viewportStylesOffset) {
+        builder.addFieldOffset(8, viewportStylesOffset, 0);
+    }
+    static createViewportStylesVector(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 startViewportStylesVector(builder, numElems) {
+        builder.startVector(4, numElems, 4);
+    }
+    static addHatchStyles(builder, hatchStylesOffset) {
+        builder.addFieldOffset(9, hatchStylesOffset, 0);
+    }
+    static createHatchStylesVector(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 startHatchStylesVector(builder, numElems) {
+        builder.startVector(4, numElems, 4);
+    }
+    static addXrayStyles(builder, xrayStylesOffset) {
+        builder.addFieldOffset(10, xrayStylesOffset, 0);
+    }
+    static createXrayStylesVector(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 startXrayStylesVector(builder, numElems) {
+        builder.startVector(4, numElems, 4);
+    }
+    static endStandardStyles(builder) {
+        const offset = builder.endObject();
+        return offset;
+    }
+    static createStandardStyles(builder, commonStylesOffset, stackLikeStylesOffset, textStylesOffset, dimensionStylesOffset, leaderStylesOffset, featureControlFrameStylesOffset, tableStylesOffset, docStylesOffset, viewportStylesOffset, hatchStylesOffset, xrayStylesOffset) {
+        StandardStyles.startStandardStyles(builder);
+        StandardStyles.addCommonStyles(builder, commonStylesOffset);
+        StandardStyles.addStackLikeStyles(builder, stackLikeStylesOffset);
+        StandardStyles.addTextStyles(builder, textStylesOffset);
+        StandardStyles.addDimensionStyles(builder, dimensionStylesOffset);
+        StandardStyles.addLeaderStyles(builder, leaderStylesOffset);
+        StandardStyles.addFeatureControlFrameStyles(builder, featureControlFrameStylesOffset);
+        StandardStyles.addTableStyles(builder, tableStylesOffset);
+        StandardStyles.addDocStyles(builder, docStylesOffset);
+        StandardStyles.addViewportStyles(builder, viewportStylesOffset);
+        StandardStyles.addHatchStyles(builder, hatchStylesOffset);
+        StandardStyles.addXrayStyles(builder, xrayStylesOffset);
+        return StandardStyles.endStandardStyles(builder);
+    }
+}

package/dist/flatbuffers/duc/standard-units.d.ts

@@ -0,0 +1,16 @@
+import * as flatbuffers from 'flatbuffers';
+import { AlternateUnits } from '../duc/alternate-units';
+import { PrimaryUnits } from '../duc/primary-units';
+export declare class StandardUnits {
+    bb: flatbuffers.ByteBuffer | null;
+    bb_pos: number;
+    __init(i: number, bb: flatbuffers.ByteBuffer): StandardUnits;
+    static getRootAsStandardUnits(bb: flatbuffers.ByteBuffer, obj?: StandardUnits): StandardUnits;
+    static getSizePrefixedRootAsStandardUnits(bb: flatbuffers.ByteBuffer, obj?: StandardUnits): StandardUnits;
+    primaryUnits(obj?: PrimaryUnits): PrimaryUnits | null;
+    alternateUnits(obj?: AlternateUnits): AlternateUnits | null;
+    static startStandardUnits(builder: flatbuffers.Builder): void;
+    static addPrimaryUnits(builder: flatbuffers.Builder, primaryUnitsOffset: flatbuffers.Offset): void;
+    static addAlternateUnits(builder: flatbuffers.Builder, alternateUnitsOffset: flatbuffers.Offset): void;
+    static endStandardUnits(builder: flatbuffers.Builder): flatbuffers.Offset;
+}

package/dist/flatbuffers/duc/standard-units.js

@@ -0,0 +1,44 @@
+// 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 { AlternateUnits } from '../duc/alternate-units';
+import { PrimaryUnits } from '../duc/primary-units';
+export class StandardUnits {
+    constructor() {
+        this.bb = null;
+        this.bb_pos = 0;
+    }
+    __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+    }
+    static getRootAsStandardUnits(bb, obj) {
+        return (obj || new StandardUnits()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    }
+    static getSizePrefixedRootAsStandardUnits(bb, obj) {
+        bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
+        return (obj || new StandardUnits()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    }
+    primaryUnits(obj) {
+        const offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? (obj || new PrimaryUnits()).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
+    }
+    alternateUnits(obj) {
+        const offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? (obj || new AlternateUnits()).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
+    }
+    static startStandardUnits(builder) {
+        builder.startObject(2);
+    }
+    static addPrimaryUnits(builder, primaryUnitsOffset) {
+        builder.addFieldOffset(0, primaryUnitsOffset, 0);
+    }
+    static addAlternateUnits(builder, alternateUnitsOffset) {
+        builder.addFieldOffset(1, alternateUnitsOffset, 0);
+    }
+    static endStandardUnits(builder) {
+        const offset = builder.endObject();
+        return offset;
+    }
+}

package/dist/flatbuffers/duc/standard-validation.d.ts

@@ -0,0 +1,16 @@
+import * as flatbuffers from 'flatbuffers';
+import { DimensionValidationRules } from '../duc/dimension-validation-rules';
+import { LayerValidationRules } from '../duc/layer-validation-rules';
+export declare class StandardValidation {
+    bb: flatbuffers.ByteBuffer | null;
+    bb_pos: number;
+    __init(i: number, bb: flatbuffers.ByteBuffer): StandardValidation;
+    static getRootAsStandardValidation(bb: flatbuffers.ByteBuffer, obj?: StandardValidation): StandardValidation;
+    static getSizePrefixedRootAsStandardValidation(bb: flatbuffers.ByteBuffer, obj?: StandardValidation): StandardValidation;
+    dimensionRules(obj?: DimensionValidationRules): DimensionValidationRules | null;
+    layerRules(obj?: LayerValidationRules): LayerValidationRules | null;
+    static startStandardValidation(builder: flatbuffers.Builder): void;
+    static addDimensionRules(builder: flatbuffers.Builder, dimensionRulesOffset: flatbuffers.Offset): void;
+    static addLayerRules(builder: flatbuffers.Builder, layerRulesOffset: flatbuffers.Offset): void;
+    static endStandardValidation(builder: flatbuffers.Builder): flatbuffers.Offset;
+}

package/dist/flatbuffers/duc/standard-validation.js

@@ -0,0 +1,44 @@
+// 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 { DimensionValidationRules } from '../duc/dimension-validation-rules';
+import { LayerValidationRules } from '../duc/layer-validation-rules';
+export class StandardValidation {
+    constructor() {
+        this.bb = null;
+        this.bb_pos = 0;
+    }
+    __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+    }
+    static getRootAsStandardValidation(bb, obj) {
+        return (obj || new StandardValidation()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    }
+    static getSizePrefixedRootAsStandardValidation(bb, obj) {
+        bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
+        return (obj || new StandardValidation()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    }
+    dimensionRules(obj) {
+        const offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? (obj || new DimensionValidationRules()).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
+    }
+    layerRules(obj) {
+        const offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? (obj || new LayerValidationRules()).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
+    }
+    static startStandardValidation(builder) {
+        builder.startObject(2);
+    }
+    static addDimensionRules(builder, dimensionRulesOffset) {
+        builder.addFieldOffset(0, dimensionRulesOffset, 0);
+    }
+    static addLayerRules(builder, layerRulesOffset) {
+        builder.addFieldOffset(1, layerRulesOffset, 0);
+    }
+    static endStandardValidation(builder) {
+        const offset = builder.endObject();
+        return offset;
+    }
+}

package/dist/flatbuffers/duc/standard-view-settings.d.ts

@@ -0,0 +1,35 @@
+import * as flatbuffers from 'flatbuffers';
+import { IdentifiedGridSettings } from '../duc/identified-grid-settings';
+import { IdentifiedSnapSettings } from '../duc/identified-snap-settings';
+import { IdentifiedUcs } from '../duc/identified-ucs';
+import { IdentifiedView } from '../duc/identified-view';
+export declare class StandardViewSettings {
+    bb: flatbuffers.ByteBuffer | null;
+    bb_pos: number;
+    __init(i: number, bb: flatbuffers.ByteBuffer): StandardViewSettings;
+    static getRootAsStandardViewSettings(bb: flatbuffers.ByteBuffer, obj?: StandardViewSettings): StandardViewSettings;
+    static getSizePrefixedRootAsStandardViewSettings(bb: flatbuffers.ByteBuffer, obj?: StandardViewSettings): StandardViewSettings;
+    views(index: number, obj?: IdentifiedView): IdentifiedView | null;
+    viewsLength(): number;
+    ucs(index: number, obj?: IdentifiedUcs): IdentifiedUcs | null;
+    ucsLength(): number;
+    gridSettings(index: number, obj?: IdentifiedGridSettings): IdentifiedGridSettings | null;
+    gridSettingsLength(): number;
+    snapSettings(index: number, obj?: IdentifiedSnapSettings): IdentifiedSnapSettings | null;
+    snapSettingsLength(): number;
+    static startStandardViewSettings(builder: flatbuffers.Builder): void;
+    static addViews(builder: flatbuffers.Builder, viewsOffset: flatbuffers.Offset): void;
+    static createViewsVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset;
+    static startViewsVector(builder: flatbuffers.Builder, numElems: number): void;
+    static addUcs(builder: flatbuffers.Builder, ucsOffset: flatbuffers.Offset): void;
+    static createUcsVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset;
+    static startUcsVector(builder: flatbuffers.Builder, numElems: number): void;
+    static addGridSettings(builder: flatbuffers.Builder, gridSettingsOffset: flatbuffers.Offset): void;
+    static createGridSettingsVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset;
+    static startGridSettingsVector(builder: flatbuffers.Builder, numElems: number): void;
+    static addSnapSettings(builder: flatbuffers.Builder, snapSettingsOffset: flatbuffers.Offset): void;
+    static createSnapSettingsVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset;
+    static startSnapSettingsVector(builder: flatbuffers.Builder, numElems: number): void;
+    static endStandardViewSettings(builder: flatbuffers.Builder): flatbuffers.Offset;
+    static createStandardViewSettings(builder: flatbuffers.Builder, viewsOffset: flatbuffers.Offset, ucsOffset: flatbuffers.Offset, gridSettingsOffset: flatbuffers.Offset, snapSettingsOffset: flatbuffers.Offset): flatbuffers.Offset;
+}

package/dist/flatbuffers/duc/standard-view-settings.js

@@ -0,0 +1,124 @@
+// 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 { IdentifiedGridSettings } from '../duc/identified-grid-settings';
+import { IdentifiedSnapSettings } from '../duc/identified-snap-settings';
+import { IdentifiedUcs } from '../duc/identified-ucs';
+import { IdentifiedView } from '../duc/identified-view';
+export class StandardViewSettings {
+    constructor() {
+        this.bb = null;
+        this.bb_pos = 0;
+    }
+    __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+    }
+    static getRootAsStandardViewSettings(bb, obj) {
+        return (obj || new StandardViewSettings()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    }
+    static getSizePrefixedRootAsStandardViewSettings(bb, obj) {
+        bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
+        return (obj || new StandardViewSettings()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    }
+    views(index, obj) {
+        const offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? (obj || new IdentifiedView()).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null;
+    }
+    viewsLength() {
+        const offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+    }
+    ucs(index, obj) {
+        const offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? (obj || new IdentifiedUcs()).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null;
+    }
+    ucsLength() {
+        const offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+    }
+    gridSettings(index, obj) {
+        const offset = this.bb.__offset(this.bb_pos, 8);
+        return offset ? (obj || new IdentifiedGridSettings()).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null;
+    }
+    gridSettingsLength() {
+        const offset = this.bb.__offset(this.bb_pos, 8);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+    }
+    snapSettings(index, obj) {
+        const offset = this.bb.__offset(this.bb_pos, 10);
+        return offset ? (obj || new IdentifiedSnapSettings()).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null;
+    }
+    snapSettingsLength() {
+        const offset = this.bb.__offset(this.bb_pos, 10);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+    }
+    static startStandardViewSettings(builder) {
+        builder.startObject(4);
+    }
+    static addViews(builder, viewsOffset) {
+        builder.addFieldOffset(0, viewsOffset, 0);
+    }
+    static createViewsVector(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 startViewsVector(builder, numElems) {
+        builder.startVector(4, numElems, 4);
+    }
+    static addUcs(builder, ucsOffset) {
+        builder.addFieldOffset(1, ucsOffset, 0);
+    }
+    static createUcsVector(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 startUcsVector(builder, numElems) {
+        builder.startVector(4, numElems, 4);
+    }
+    static addGridSettings(builder, gridSettingsOffset) {
+        builder.addFieldOffset(2, gridSettingsOffset, 0);
+    }
+    static createGridSettingsVector(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 startGridSettingsVector(builder, numElems) {
+        builder.startVector(4, numElems, 4);
+    }
+    static addSnapSettings(builder, snapSettingsOffset) {
+        builder.addFieldOffset(3, snapSettingsOffset, 0);
+    }
+    static createSnapSettingsVector(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 startSnapSettingsVector(builder, numElems) {
+        builder.startVector(4, numElems, 4);
+    }
+    static endStandardViewSettings(builder) {
+        const offset = builder.endObject();
+        return offset;
+    }
+    static createStandardViewSettings(builder, viewsOffset, ucsOffset, gridSettingsOffset, snapSettingsOffset) {
+        StandardViewSettings.startStandardViewSettings(builder);
+        StandardViewSettings.addViews(builder, viewsOffset);
+        StandardViewSettings.addUcs(builder, ucsOffset);
+        StandardViewSettings.addGridSettings(builder, gridSettingsOffset);
+        StandardViewSettings.addSnapSettings(builder, snapSettingsOffset);
+        return StandardViewSettings.endStandardViewSettings(builder);
+    }
+}