ducjs 1.0.0

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

@@ -0,0 +1,49 @@
+import { DucArrowElement } from '../duc/duc-arrow-element';
+import { DucBlockInstanceElement } from '../duc/duc-block-instance-element';
+import { DucDimensionElement } from '../duc/duc-dimension-element';
+import { DucDocElement } from '../duc/duc-doc-element';
+import { DucEllipseElement } from '../duc/duc-ellipse-element';
+import { DucEmbeddableElement } from '../duc/duc-embeddable-element';
+import { DucFeatureControlFrameElement } from '../duc/duc-feature-control-frame-element';
+import { DucFrameElement } from '../duc/duc-frame-element';
+import { DucFreeDrawElement } from '../duc/duc-free-draw-element';
+import { DucImageElement } from '../duc/duc-image-element';
+import { DucLeaderElement } from '../duc/duc-leader-element';
+import { DucLinearElement } from '../duc/duc-linear-element';
+import { DucMermaidElement } from '../duc/duc-mermaid-element';
+import { DucParametricElement } from '../duc/duc-parametric-element';
+import { DucPdfElement } from '../duc/duc-pdf-element';
+import { DucPlotElement } from '../duc/duc-plot-element';
+import { DucPolygonElement } from '../duc/duc-polygon-element';
+import { DucRectangleElement } from '../duc/duc-rectangle-element';
+import { DucTableElement } from '../duc/duc-table-element';
+import { DucTextElement } from '../duc/duc-text-element';
+import { DucViewportElement } from '../duc/duc-viewport-element';
+import { DucXRayElement } from '../duc/duc-xray-element';
+export declare enum Element {
+    NONE = 0,
+    DucRectangleElement = 1,
+    DucPolygonElement = 2,
+    DucEllipseElement = 3,
+    DucEmbeddableElement = 4,
+    DucPdfElement = 5,
+    DucMermaidElement = 6,
+    DucTableElement = 7,
+    DucImageElement = 8,
+    DucTextElement = 9,
+    DucLinearElement = 10,
+    DucArrowElement = 11,
+    DucFreeDrawElement = 12,
+    DucBlockInstanceElement = 13,
+    DucFrameElement = 14,
+    DucPlotElement = 15,
+    DucViewportElement = 16,
+    DucXRayElement = 17,
+    DucLeaderElement = 18,
+    DucDimensionElement = 19,
+    DucFeatureControlFrameElement = 20,
+    DucDocElement = 21,
+    DucParametricElement = 22
+}
+export declare function unionToElement(type: Element, accessor: (obj: DucArrowElement | DucBlockInstanceElement | DucDimensionElement | DucDocElement | DucEllipseElement | DucEmbeddableElement | DucFeatureControlFrameElement | DucFrameElement | DucFreeDrawElement | DucImageElement | DucLeaderElement | DucLinearElement | DucMermaidElement | DucParametricElement | DucPdfElement | DucPlotElement | DucPolygonElement | DucRectangleElement | DucTableElement | DucTextElement | DucViewportElement | DucXRayElement) => DucArrowElement | DucBlockInstanceElement | DucDimensionElement | DucDocElement | DucEllipseElement | DucEmbeddableElement | DucFeatureControlFrameElement | DucFrameElement | DucFreeDrawElement | DucImageElement | DucLeaderElement | DucLinearElement | DucMermaidElement | DucParametricElement | DucPdfElement | DucPlotElement | DucPolygonElement | DucRectangleElement | DucTableElement | DucTextElement | DucViewportElement | DucXRayElement | null): DucArrowElement | DucBlockInstanceElement | DucDimensionElement | DucDocElement | DucEllipseElement | DucEmbeddableElement | DucFeatureControlFrameElement | DucFrameElement | DucFreeDrawElement | DucImageElement | DucLeaderElement | DucLinearElement | DucMermaidElement | DucParametricElement | DucPdfElement | DucPlotElement | DucPolygonElement | DucRectangleElement | DucTableElement | DucTextElement | DucViewportElement | DucXRayElement | null;
+export declare function unionListToElement(type: Element, accessor: (index: number, obj: DucArrowElement | DucBlockInstanceElement | DucDimensionElement | DucDocElement | DucEllipseElement | DucEmbeddableElement | DucFeatureControlFrameElement | DucFrameElement | DucFreeDrawElement | DucImageElement | DucLeaderElement | DucLinearElement | DucMermaidElement | DucParametricElement | DucPdfElement | DucPlotElement | DucPolygonElement | DucRectangleElement | DucTableElement | DucTextElement | DucViewportElement | DucXRayElement) => DucArrowElement | DucBlockInstanceElement | DucDimensionElement | DucDocElement | DucEllipseElement | DucEmbeddableElement | DucFeatureControlFrameElement | DucFrameElement | DucFreeDrawElement | DucImageElement | DucLeaderElement | DucLinearElement | DucMermaidElement | DucParametricElement | DucPdfElement | DucPlotElement | DucPolygonElement | DucRectangleElement | DucTableElement | DucTextElement | DucViewportElement | DucXRayElement | null, index: number): DucArrowElement | DucBlockInstanceElement | DucDimensionElement | DucDocElement | DucEllipseElement | DucEmbeddableElement | DucFeatureControlFrameElement | DucFrameElement | DucFreeDrawElement | DucImageElement | DucLeaderElement | DucLinearElement | DucMermaidElement | DucParametricElement | DucPdfElement | DucPlotElement | DucPolygonElement | DucRectangleElement | DucTableElement | DucTextElement | DucViewportElement | DucXRayElement | null;

package/dist/flatbuffers/duc/element.js

@@ -0,0 +1,106 @@
+// 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 { DucArrowElement } from '../duc/duc-arrow-element';
+import { DucBlockInstanceElement } from '../duc/duc-block-instance-element';
+import { DucDimensionElement } from '../duc/duc-dimension-element';
+import { DucDocElement } from '../duc/duc-doc-element';
+import { DucEllipseElement } from '../duc/duc-ellipse-element';
+import { DucEmbeddableElement } from '../duc/duc-embeddable-element';
+import { DucFeatureControlFrameElement } from '../duc/duc-feature-control-frame-element';
+import { DucFrameElement } from '../duc/duc-frame-element';
+import { DucFreeDrawElement } from '../duc/duc-free-draw-element';
+import { DucImageElement } from '../duc/duc-image-element';
+import { DucLeaderElement } from '../duc/duc-leader-element';
+import { DucLinearElement } from '../duc/duc-linear-element';
+import { DucMermaidElement } from '../duc/duc-mermaid-element';
+import { DucParametricElement } from '../duc/duc-parametric-element';
+import { DucPdfElement } from '../duc/duc-pdf-element';
+import { DucPlotElement } from '../duc/duc-plot-element';
+import { DucPolygonElement } from '../duc/duc-polygon-element';
+import { DucRectangleElement } from '../duc/duc-rectangle-element';
+import { DucTableElement } from '../duc/duc-table-element';
+import { DucTextElement } from '../duc/duc-text-element';
+import { DucViewportElement } from '../duc/duc-viewport-element';
+import { DucXRayElement } from '../duc/duc-xray-element';
+export var Element;
+(function (Element) {
+    Element[Element["NONE"] = 0] = "NONE";
+    Element[Element["DucRectangleElement"] = 1] = "DucRectangleElement";
+    Element[Element["DucPolygonElement"] = 2] = "DucPolygonElement";
+    Element[Element["DucEllipseElement"] = 3] = "DucEllipseElement";
+    Element[Element["DucEmbeddableElement"] = 4] = "DucEmbeddableElement";
+    Element[Element["DucPdfElement"] = 5] = "DucPdfElement";
+    Element[Element["DucMermaidElement"] = 6] = "DucMermaidElement";
+    Element[Element["DucTableElement"] = 7] = "DucTableElement";
+    Element[Element["DucImageElement"] = 8] = "DucImageElement";
+    Element[Element["DucTextElement"] = 9] = "DucTextElement";
+    Element[Element["DucLinearElement"] = 10] = "DucLinearElement";
+    Element[Element["DucArrowElement"] = 11] = "DucArrowElement";
+    Element[Element["DucFreeDrawElement"] = 12] = "DucFreeDrawElement";
+    Element[Element["DucBlockInstanceElement"] = 13] = "DucBlockInstanceElement";
+    Element[Element["DucFrameElement"] = 14] = "DucFrameElement";
+    Element[Element["DucPlotElement"] = 15] = "DucPlotElement";
+    Element[Element["DucViewportElement"] = 16] = "DucViewportElement";
+    Element[Element["DucXRayElement"] = 17] = "DucXRayElement";
+    Element[Element["DucLeaderElement"] = 18] = "DucLeaderElement";
+    Element[Element["DucDimensionElement"] = 19] = "DucDimensionElement";
+    Element[Element["DucFeatureControlFrameElement"] = 20] = "DucFeatureControlFrameElement";
+    Element[Element["DucDocElement"] = 21] = "DucDocElement";
+    Element[Element["DucParametricElement"] = 22] = "DucParametricElement";
+})(Element || (Element = {}));
+export function unionToElement(type, accessor) {
+    switch (Element[type]) {
+        case 'NONE': return null;
+        case 'DucRectangleElement': return accessor(new DucRectangleElement());
+        case 'DucPolygonElement': return accessor(new DucPolygonElement());
+        case 'DucEllipseElement': return accessor(new DucEllipseElement());
+        case 'DucEmbeddableElement': return accessor(new DucEmbeddableElement());
+        case 'DucPdfElement': return accessor(new DucPdfElement());
+        case 'DucMermaidElement': return accessor(new DucMermaidElement());
+        case 'DucTableElement': return accessor(new DucTableElement());
+        case 'DucImageElement': return accessor(new DucImageElement());
+        case 'DucTextElement': return accessor(new DucTextElement());
+        case 'DucLinearElement': return accessor(new DucLinearElement());
+        case 'DucArrowElement': return accessor(new DucArrowElement());
+        case 'DucFreeDrawElement': return accessor(new DucFreeDrawElement());
+        case 'DucBlockInstanceElement': return accessor(new DucBlockInstanceElement());
+        case 'DucFrameElement': return accessor(new DucFrameElement());
+        case 'DucPlotElement': return accessor(new DucPlotElement());
+        case 'DucViewportElement': return accessor(new DucViewportElement());
+        case 'DucXRayElement': return accessor(new DucXRayElement());
+        case 'DucLeaderElement': return accessor(new DucLeaderElement());
+        case 'DucDimensionElement': return accessor(new DucDimensionElement());
+        case 'DucFeatureControlFrameElement': return accessor(new DucFeatureControlFrameElement());
+        case 'DucDocElement': return accessor(new DucDocElement());
+        case 'DucParametricElement': return accessor(new DucParametricElement());
+        default: return null;
+    }
+}
+export function unionListToElement(type, accessor, index) {
+    switch (Element[type]) {
+        case 'NONE': return null;
+        case 'DucRectangleElement': return accessor(index, new DucRectangleElement());
+        case 'DucPolygonElement': return accessor(index, new DucPolygonElement());
+        case 'DucEllipseElement': return accessor(index, new DucEllipseElement());
+        case 'DucEmbeddableElement': return accessor(index, new DucEmbeddableElement());
+        case 'DucPdfElement': return accessor(index, new DucPdfElement());
+        case 'DucMermaidElement': return accessor(index, new DucMermaidElement());
+        case 'DucTableElement': return accessor(index, new DucTableElement());
+        case 'DucImageElement': return accessor(index, new DucImageElement());
+        case 'DucTextElement': return accessor(index, new DucTextElement());
+        case 'DucLinearElement': return accessor(index, new DucLinearElement());
+        case 'DucArrowElement': return accessor(index, new DucArrowElement());
+        case 'DucFreeDrawElement': return accessor(index, new DucFreeDrawElement());
+        case 'DucBlockInstanceElement': return accessor(index, new DucBlockInstanceElement());
+        case 'DucFrameElement': return accessor(index, new DucFrameElement());
+        case 'DucPlotElement': return accessor(index, new DucPlotElement());
+        case 'DucViewportElement': return accessor(index, new DucViewportElement());
+        case 'DucXRayElement': return accessor(index, new DucXRayElement());
+        case 'DucLeaderElement': return accessor(index, new DucLeaderElement());
+        case 'DucDimensionElement': return accessor(index, new DucDimensionElement());
+        case 'DucFeatureControlFrameElement': return accessor(index, new DucFeatureControlFrameElement());
+        case 'DucDocElement': return accessor(index, new DucDocElement());
+        case 'DucParametricElement': return accessor(index, new DucParametricElement());
+        default: return null;
+    }
+}

package/dist/flatbuffers/duc/exported-data-state.d.ts

@@ -0,0 +1,87 @@
+import * as flatbuffers from 'flatbuffers';
+import { DictionaryEntry } from '../duc/dictionary-entry';
+import { DucBlock } from '../duc/duc-block';
+import { DucExternalFileEntry } from '../duc/duc-external-file-entry';
+import { DucGlobalState } from '../duc/duc-global-state';
+import { DucGroup } from '../duc/duc-group';
+import { DucLayer } from '../duc/duc-layer';
+import { DucLocalState } from '../duc/duc-local-state';
+import { DucRegion } from '../duc/duc-region';
+import { ElementWrapper } from '../duc/element-wrapper';
+import { Standard } from '../duc/standard';
+import { VersionGraph } from '../duc/version-graph';
+export declare class ExportedDataState {
+    bb: flatbuffers.ByteBuffer | null;
+    bb_pos: number;
+    __init(i: number, bb: flatbuffers.ByteBuffer): ExportedDataState;
+    static getRootAsExportedDataState(bb: flatbuffers.ByteBuffer, obj?: ExportedDataState): ExportedDataState;
+    static getSizePrefixedRootAsExportedDataState(bb: flatbuffers.ByteBuffer, obj?: ExportedDataState): ExportedDataState;
+    static bufferHasIdentifier(bb: flatbuffers.ByteBuffer): boolean;
+    type(): string | null;
+    type(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
+    versionLegacy(): number;
+    source(): string | null;
+    source(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
+    version(): string | null;
+    version(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
+    thumbnail(index: number): number | null;
+    thumbnailLength(): number;
+    thumbnailArray(): Uint8Array | null;
+    dictionary(index: number, obj?: DictionaryEntry): DictionaryEntry | null;
+    dictionaryLength(): number;
+    elements(index: number, obj?: ElementWrapper): ElementWrapper | null;
+    elementsLength(): number;
+    blocks(index: number, obj?: DucBlock): DucBlock | null;
+    blocksLength(): number;
+    groups(index: number, obj?: DucGroup): DucGroup | null;
+    groupsLength(): number;
+    regions(index: number, obj?: DucRegion): DucRegion | null;
+    regionsLength(): number;
+    layers(index: number, obj?: DucLayer): DucLayer | null;
+    layersLength(): number;
+    standards(index: number, obj?: Standard): Standard | null;
+    standardsLength(): number;
+    ducLocalState(obj?: DucLocalState): DucLocalState | null;
+    ducGlobalState(obj?: DucGlobalState): DucGlobalState | null;
+    externalFiles(index: number, obj?: DucExternalFileEntry): DucExternalFileEntry | null;
+    externalFilesLength(): number;
+    versionGraph(obj?: VersionGraph): VersionGraph | null;
+    static startExportedDataState(builder: flatbuffers.Builder): void;
+    static addType(builder: flatbuffers.Builder, typeOffset: flatbuffers.Offset): void;
+    static addVersionLegacy(builder: flatbuffers.Builder, versionLegacy: number): void;
+    static addSource(builder: flatbuffers.Builder, sourceOffset: flatbuffers.Offset): void;
+    static addVersion(builder: flatbuffers.Builder, versionOffset: flatbuffers.Offset): void;
+    static addThumbnail(builder: flatbuffers.Builder, thumbnailOffset: flatbuffers.Offset): void;
+    static createThumbnailVector(builder: flatbuffers.Builder, data: number[] | Uint8Array): flatbuffers.Offset;
+    static startThumbnailVector(builder: flatbuffers.Builder, numElems: number): void;
+    static addDictionary(builder: flatbuffers.Builder, dictionaryOffset: flatbuffers.Offset): void;
+    static createDictionaryVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset;
+    static startDictionaryVector(builder: flatbuffers.Builder, numElems: number): void;
+    static addElements(builder: flatbuffers.Builder, elementsOffset: flatbuffers.Offset): void;
+    static createElementsVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset;
+    static startElementsVector(builder: flatbuffers.Builder, numElems: number): void;
+    static addBlocks(builder: flatbuffers.Builder, blocksOffset: flatbuffers.Offset): void;
+    static createBlocksVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset;
+    static startBlocksVector(builder: flatbuffers.Builder, numElems: number): void;
+    static addGroups(builder: flatbuffers.Builder, groupsOffset: flatbuffers.Offset): void;
+    static createGroupsVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset;
+    static startGroupsVector(builder: flatbuffers.Builder, numElems: number): void;
+    static addRegions(builder: flatbuffers.Builder, regionsOffset: flatbuffers.Offset): void;
+    static createRegionsVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset;
+    static startRegionsVector(builder: flatbuffers.Builder, numElems: number): void;
+    static addLayers(builder: flatbuffers.Builder, layersOffset: flatbuffers.Offset): void;
+    static createLayersVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset;
+    static startLayersVector(builder: flatbuffers.Builder, numElems: number): void;
+    static addStandards(builder: flatbuffers.Builder, standardsOffset: flatbuffers.Offset): void;
+    static createStandardsVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset;
+    static startStandardsVector(builder: flatbuffers.Builder, numElems: number): void;
+    static addDucLocalState(builder: flatbuffers.Builder, ducLocalStateOffset: flatbuffers.Offset): void;
+    static addDucGlobalState(builder: flatbuffers.Builder, ducGlobalStateOffset: flatbuffers.Offset): void;
+    static addExternalFiles(builder: flatbuffers.Builder, externalFilesOffset: flatbuffers.Offset): void;
+    static createExternalFilesVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset;
+    static startExternalFilesVector(builder: flatbuffers.Builder, numElems: number): void;
+    static addVersionGraph(builder: flatbuffers.Builder, versionGraphOffset: flatbuffers.Offset): void;
+    static endExportedDataState(builder: flatbuffers.Builder): flatbuffers.Offset;
+    static finishExportedDataStateBuffer(builder: flatbuffers.Builder, offset: flatbuffers.Offset): void;
+    static finishSizePrefixedExportedDataStateBuffer(builder: flatbuffers.Builder, offset: flatbuffers.Offset): void;
+}

package/dist/flatbuffers/duc/exported-data-state.js

@@ -0,0 +1,290 @@
+// 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 { DictionaryEntry } from '../duc/dictionary-entry';
+import { DucBlock } from '../duc/duc-block';
+import { DucExternalFileEntry } from '../duc/duc-external-file-entry';
+import { DucGlobalState } from '../duc/duc-global-state';
+import { DucGroup } from '../duc/duc-group';
+import { DucLayer } from '../duc/duc-layer';
+import { DucLocalState } from '../duc/duc-local-state';
+import { DucRegion } from '../duc/duc-region';
+import { ElementWrapper } from '../duc/element-wrapper';
+import { Standard } from '../duc/standard';
+import { VersionGraph } from '../duc/version-graph';
+export class ExportedDataState {
+    constructor() {
+        this.bb = null;
+        this.bb_pos = 0;
+    }
+    __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+    }
+    static getRootAsExportedDataState(bb, obj) {
+        return (obj || new ExportedDataState()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    }
+    static getSizePrefixedRootAsExportedDataState(bb, obj) {
+        bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
+        return (obj || new ExportedDataState()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    }
+    static bufferHasIdentifier(bb) {
+        return bb.__has_identifier('DUC_');
+    }
+    type(optionalEncoding) {
+        const offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+    }
+    versionLegacy() {
+        const offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
+    }
+    source(optionalEncoding) {
+        const offset = this.bb.__offset(this.bb_pos, 8);
+        return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+    }
+    version(optionalEncoding) {
+        const offset = this.bb.__offset(this.bb_pos, 10);
+        return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+    }
+    thumbnail(index) {
+        const offset = this.bb.__offset(this.bb_pos, 12);
+        return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0;
+    }
+    thumbnailLength() {
+        const offset = this.bb.__offset(this.bb_pos, 12);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+    }
+    thumbnailArray() {
+        const offset = this.bb.__offset(this.bb_pos, 12);
+        return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
+    }
+    dictionary(index, obj) {
+        const offset = this.bb.__offset(this.bb_pos, 14);
+        return offset ? (obj || new DictionaryEntry()).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null;
+    }
+    dictionaryLength() {
+        const offset = this.bb.__offset(this.bb_pos, 14);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+    }
+    elements(index, obj) {
+        const offset = this.bb.__offset(this.bb_pos, 16);
+        return offset ? (obj || new ElementWrapper()).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null;
+    }
+    elementsLength() {
+        const offset = this.bb.__offset(this.bb_pos, 16);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+    }
+    blocks(index, obj) {
+        const offset = this.bb.__offset(this.bb_pos, 18);
+        return offset ? (obj || new DucBlock()).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null;
+    }
+    blocksLength() {
+        const offset = this.bb.__offset(this.bb_pos, 18);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+    }
+    groups(index, obj) {
+        const offset = this.bb.__offset(this.bb_pos, 20);
+        return offset ? (obj || new DucGroup()).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null;
+    }
+    groupsLength() {
+        const offset = this.bb.__offset(this.bb_pos, 20);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+    }
+    regions(index, obj) {
+        const offset = this.bb.__offset(this.bb_pos, 22);
+        return offset ? (obj || new DucRegion()).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null;
+    }
+    regionsLength() {
+        const offset = this.bb.__offset(this.bb_pos, 22);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+    }
+    layers(index, obj) {
+        const offset = this.bb.__offset(this.bb_pos, 24);
+        return offset ? (obj || new DucLayer()).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null;
+    }
+    layersLength() {
+        const offset = this.bb.__offset(this.bb_pos, 24);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+    }
+    standards(index, obj) {
+        const offset = this.bb.__offset(this.bb_pos, 26);
+        return offset ? (obj || new Standard()).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null;
+    }
+    standardsLength() {
+        const offset = this.bb.__offset(this.bb_pos, 26);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+    }
+    ducLocalState(obj) {
+        const offset = this.bb.__offset(this.bb_pos, 28);
+        return offset ? (obj || new DucLocalState()).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
+    }
+    ducGlobalState(obj) {
+        const offset = this.bb.__offset(this.bb_pos, 30);
+        return offset ? (obj || new DucGlobalState()).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
+    }
+    externalFiles(index, obj) {
+        const offset = this.bb.__offset(this.bb_pos, 32);
+        return offset ? (obj || new DucExternalFileEntry()).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null;
+    }
+    externalFilesLength() {
+        const offset = this.bb.__offset(this.bb_pos, 32);
+        return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
+    }
+    versionGraph(obj) {
+        const offset = this.bb.__offset(this.bb_pos, 34);
+        return offset ? (obj || new VersionGraph()).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
+    }
+    static startExportedDataState(builder) {
+        builder.startObject(16);
+    }
+    static addType(builder, typeOffset) {
+        builder.addFieldOffset(0, typeOffset, 0);
+    }
+    static addVersionLegacy(builder, versionLegacy) {
+        builder.addFieldInt32(1, versionLegacy, 0);
+    }
+    static addSource(builder, sourceOffset) {
+        builder.addFieldOffset(2, sourceOffset, 0);
+    }
+    static addVersion(builder, versionOffset) {
+        builder.addFieldOffset(3, versionOffset, 0);
+    }
+    static addThumbnail(builder, thumbnailOffset) {
+        builder.addFieldOffset(4, thumbnailOffset, 0);
+    }
+    static createThumbnailVector(builder, data) {
+        builder.startVector(1, data.length, 1);
+        for (let i = data.length - 1; i >= 0; i--) {
+            builder.addInt8(data[i]);
+        }
+        return builder.endVector();
+    }
+    static startThumbnailVector(builder, numElems) {
+        builder.startVector(1, numElems, 1);
+    }
+    static addDictionary(builder, dictionaryOffset) {
+        builder.addFieldOffset(5, dictionaryOffset, 0);
+    }
+    static createDictionaryVector(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 startDictionaryVector(builder, numElems) {
+        builder.startVector(4, numElems, 4);
+    }
+    static addElements(builder, elementsOffset) {
+        builder.addFieldOffset(6, elementsOffset, 0);
+    }
+    static createElementsVector(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 startElementsVector(builder, numElems) {
+        builder.startVector(4, numElems, 4);
+    }
+    static addBlocks(builder, blocksOffset) {
+        builder.addFieldOffset(7, blocksOffset, 0);
+    }
+    static createBlocksVector(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 startBlocksVector(builder, numElems) {
+        builder.startVector(4, numElems, 4);
+    }
+    static addGroups(builder, groupsOffset) {
+        builder.addFieldOffset(8, groupsOffset, 0);
+    }
+    static createGroupsVector(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 startGroupsVector(builder, numElems) {
+        builder.startVector(4, numElems, 4);
+    }
+    static addRegions(builder, regionsOffset) {
+        builder.addFieldOffset(9, regionsOffset, 0);
+    }
+    static createRegionsVector(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 startRegionsVector(builder, numElems) {
+        builder.startVector(4, numElems, 4);
+    }
+    static addLayers(builder, layersOffset) {
+        builder.addFieldOffset(10, layersOffset, 0);
+    }
+    static createLayersVector(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 startLayersVector(builder, numElems) {
+        builder.startVector(4, numElems, 4);
+    }
+    static addStandards(builder, standardsOffset) {
+        builder.addFieldOffset(11, standardsOffset, 0);
+    }
+    static createStandardsVector(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 startStandardsVector(builder, numElems) {
+        builder.startVector(4, numElems, 4);
+    }
+    static addDucLocalState(builder, ducLocalStateOffset) {
+        builder.addFieldOffset(12, ducLocalStateOffset, 0);
+    }
+    static addDucGlobalState(builder, ducGlobalStateOffset) {
+        builder.addFieldOffset(13, ducGlobalStateOffset, 0);
+    }
+    static addExternalFiles(builder, externalFilesOffset) {
+        builder.addFieldOffset(14, externalFilesOffset, 0);
+    }
+    static createExternalFilesVector(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 startExternalFilesVector(builder, numElems) {
+        builder.startVector(4, numElems, 4);
+    }
+    static addVersionGraph(builder, versionGraphOffset) {
+        builder.addFieldOffset(15, versionGraphOffset, 0);
+    }
+    static endExportedDataState(builder) {
+        const offset = builder.endObject();
+        return offset;
+    }
+    static finishExportedDataStateBuffer(builder, offset) {
+        builder.finish(offset, 'DUC_');
+    }
+    static finishSizePrefixedExportedDataStateBuffer(builder, offset) {
+        builder.finish(offset, 'DUC_', true);
+    }
+}

package/dist/flatbuffers/duc/fcfbetween-modifier.d.ts

@@ -0,0 +1,17 @@
+import * as flatbuffers from 'flatbuffers';
+export declare class FCFBetweenModifier {
+    bb: flatbuffers.ByteBuffer | null;
+    bb_pos: number;
+    __init(i: number, bb: flatbuffers.ByteBuffer): FCFBetweenModifier;
+    static getRootAsFCFBetweenModifier(bb: flatbuffers.ByteBuffer, obj?: FCFBetweenModifier): FCFBetweenModifier;
+    static getSizePrefixedRootAsFCFBetweenModifier(bb: flatbuffers.ByteBuffer, obj?: FCFBetweenModifier): FCFBetweenModifier;
+    start(): string | null;
+    start(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
+    end(): string | null;
+    end(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
+    static startFCFBetweenModifier(builder: flatbuffers.Builder): void;
+    static addStart(builder: flatbuffers.Builder, startOffset: flatbuffers.Offset): void;
+    static addEnd(builder: flatbuffers.Builder, endOffset: flatbuffers.Offset): void;
+    static endFCFBetweenModifier(builder: flatbuffers.Builder): flatbuffers.Offset;
+    static createFCFBetweenModifier(builder: flatbuffers.Builder, startOffset: flatbuffers.Offset, endOffset: flatbuffers.Offset): flatbuffers.Offset;
+}

package/dist/flatbuffers/duc/fcfbetween-modifier.js

@@ -0,0 +1,48 @@
+// 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 FCFBetweenModifier {
+    constructor() {
+        this.bb = null;
+        this.bb_pos = 0;
+    }
+    __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+    }
+    static getRootAsFCFBetweenModifier(bb, obj) {
+        return (obj || new FCFBetweenModifier()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    }
+    static getSizePrefixedRootAsFCFBetweenModifier(bb, obj) {
+        bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
+        return (obj || new FCFBetweenModifier()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    }
+    start(optionalEncoding) {
+        const offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+    }
+    end(optionalEncoding) {
+        const offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+    }
+    static startFCFBetweenModifier(builder) {
+        builder.startObject(2);
+    }
+    static addStart(builder, startOffset) {
+        builder.addFieldOffset(0, startOffset, 0);
+    }
+    static addEnd(builder, endOffset) {
+        builder.addFieldOffset(1, endOffset, 0);
+    }
+    static endFCFBetweenModifier(builder) {
+        const offset = builder.endObject();
+        return offset;
+    }
+    static createFCFBetweenModifier(builder, startOffset, endOffset) {
+        FCFBetweenModifier.startFCFBetweenModifier(builder);
+        FCFBetweenModifier.addStart(builder, startOffset);
+        FCFBetweenModifier.addEnd(builder, endOffset);
+        return FCFBetweenModifier.endFCFBetweenModifier(builder);
+    }
+}

package/dist/flatbuffers/duc/fcfdatum-definition.d.ts

@@ -0,0 +1,16 @@
+import * as flatbuffers from 'flatbuffers';
+import { DucPointBinding } from '../duc/duc-point-binding';
+export declare class FCFDatumDefinition {
+    bb: flatbuffers.ByteBuffer | null;
+    bb_pos: number;
+    __init(i: number, bb: flatbuffers.ByteBuffer): FCFDatumDefinition;
+    static getRootAsFCFDatumDefinition(bb: flatbuffers.ByteBuffer, obj?: FCFDatumDefinition): FCFDatumDefinition;
+    static getSizePrefixedRootAsFCFDatumDefinition(bb: flatbuffers.ByteBuffer, obj?: FCFDatumDefinition): FCFDatumDefinition;
+    letter(): string | null;
+    letter(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
+    featureBinding(obj?: DucPointBinding): DucPointBinding | null;
+    static startFCFDatumDefinition(builder: flatbuffers.Builder): void;
+    static addLetter(builder: flatbuffers.Builder, letterOffset: flatbuffers.Offset): void;
+    static addFeatureBinding(builder: flatbuffers.Builder, featureBindingOffset: flatbuffers.Offset): void;
+    static endFCFDatumDefinition(builder: flatbuffers.Builder): flatbuffers.Offset;
+}

package/dist/flatbuffers/duc/fcfdatum-definition.js

@@ -0,0 +1,43 @@
+// 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 { DucPointBinding } from '../duc/duc-point-binding';
+export class FCFDatumDefinition {
+    constructor() {
+        this.bb = null;
+        this.bb_pos = 0;
+    }
+    __init(i, bb) {
+        this.bb_pos = i;
+        this.bb = bb;
+        return this;
+    }
+    static getRootAsFCFDatumDefinition(bb, obj) {
+        return (obj || new FCFDatumDefinition()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    }
+    static getSizePrefixedRootAsFCFDatumDefinition(bb, obj) {
+        bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
+        return (obj || new FCFDatumDefinition()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+    }
+    letter(optionalEncoding) {
+        const offset = this.bb.__offset(this.bb_pos, 4);
+        return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
+    }
+    featureBinding(obj) {
+        const offset = this.bb.__offset(this.bb_pos, 6);
+        return offset ? (obj || new DucPointBinding()).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
+    }
+    static startFCFDatumDefinition(builder) {
+        builder.startObject(2);
+    }
+    static addLetter(builder, letterOffset) {
+        builder.addFieldOffset(0, letterOffset, 0);
+    }
+    static addFeatureBinding(builder, featureBindingOffset) {
+        builder.addFieldOffset(1, featureBindingOffset, 0);
+    }
+    static endFCFDatumDefinition(builder) {
+        const offset = builder.endObject();
+        return offset;
+    }
+}