@lionweb/delta-protocol-test-cli 0.0.1-alpha.0

package/dist/gen/Shapes.g.js

@@ -0,0 +1,914 @@
+// Copyright 2025 TRUMPF Laser SE and other contributors
+//
+// Licensed under the Apache License, Version 2.0 (the "License")
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// SPDX-FileCopyrightText: 2025 TRUMPF Laser SE and other contributors
+// SPDX-License-Identifier: Apache-2.0
+// Warning: this file is generated!
+// Modifying it by hand is useless at best, and sabotage at worst.
+/*
+ * language's metadata:
+ *     name:    Shapes
+ *     version: 1
+ *     key:     key-Shapes
+ *     id:      id-Shapes
+ */
+import { Annotation, Concept, Containment, Enumeration, EnumerationLiteral, Interface, Language, PrimitiveType, Property, Reference } from "@lionweb/core";
+import { LionCore_builtinsBase, NodeBase, OptionalMultiContainmentValueManager, OptionalMultiReferenceValueManager, OptionalPropertyValueManager, OptionalSingleContainmentValueManager, OptionalSingleReferenceValueManager, RequiredMultiContainmentValueManager, RequiredMultiReferenceValueManager, RequiredPropertyValueManager, RequiredSingleContainmentValueManager, RequiredSingleReferenceValueManager } from "@lionweb/class-core";
+export class ShapesBase {
+    constructor() {
+        this._language = new Language("Shapes", "1", "id-Shapes", "key-Shapes");
+        this._Circle = new Concept(this._language, "Circle", "key-Circle", "id-Circle", false);
+        this._Circle_r = new Property(this._Circle, "r", "key-r", "id-r");
+        this._Circle_center = new Containment(this._Circle, "center", "key-center", "id-center");
+        this._Coord = new Concept(this._language, "Coord", "key-Coord", "id-Coord", false);
+        this._Coord_x = new Property(this._Coord, "x", "key-x", "id-x");
+        this._Coord_y = new Property(this._Coord, "y", "key-y", "id-y");
+        this._Coord_z = new Property(this._Coord, "z", "key-z", "id-z");
+        this._Geometry = new Concept(this._language, "Geometry", "key-Geometry", "id-Geometry", false).isPartition();
+        this._Geometry_shapes = new Containment(this._Geometry, "shapes", "key-shapes", "id-shapes").isOptional().isMultiple();
+        this._Geometry_documentation = new Containment(this._Geometry, "documentation", "key-documentation", "id-documentation").isOptional();
+        this._IShape = new Interface(this._language, "IShape", "key-IShape", "id-IShape");
+        this._IShape_uuid = new Property(this._IShape, "uuid", "key-uuid", "id-uuid");
+        this._IShape_fixpoints = new Containment(this._IShape, "fixpoints", "key-fixpoints", "id-fixpoints").isOptional().isMultiple();
+        this._Line = new Concept(this._language, "Line", "key-Line", "id-Line", false);
+        this._Line_start = new Containment(this._Line, "start", "key-start", "id-start");
+        this._Line_end = new Containment(this._Line, "end", "key-end", "id-end");
+        this._OffsetDuplicate = new Concept(this._language, "OffsetDuplicate", "key-OffsetDuplicate", "id-OffsetDuplicate", false);
+        this._OffsetDuplicate_offset = new Containment(this._OffsetDuplicate, "offset", "key-offset", "id-offset");
+        this._OffsetDuplicate_source = new Reference(this._OffsetDuplicate, "source", "key-source", "id-source");
+        this._OffsetDuplicate_altSource = new Reference(this._OffsetDuplicate, "altSource", "key-alt-source", "id-alt-source").isOptional();
+        this._OffsetDuplicate_docs = new Containment(this._OffsetDuplicate, "docs", "key-docs", "id-docs").isOptional();
+        this._OffsetDuplicate_secretDocs = new Containment(this._OffsetDuplicate, "secretDocs", "key-secret-docs", "id-secret-docs").isOptional();
+        this._Shape = new Concept(this._language, "Shape", "key-Shape", "id-Shape", true);
+        this._Shape_shapeDocs = new Containment(this._Shape, "shapeDocs", "key-shape-docs", "id-shape-docs").isOptional();
+        this._CompositeShape = new Concept(this._language, "CompositeShape", "key-CompositeShape", "id-CompositeShape", false);
+        this._CompositeShape_parts = new Containment(this._CompositeShape, "parts", "key-parts", "id-parts").isMultiple();
+        this._CompositeShape_disabledParts = new Containment(this._CompositeShape, "disabledParts", "key-disabled-parts", "id-disabled-parts").isMultiple();
+        this._CompositeShape_evilPart = new Containment(this._CompositeShape, "evilPart", "key-evil-part", "id-evil-part");
+        this._ReferenceGeometry = new Concept(this._language, "ReferenceGeometry", "key-ReferenceGeometry", "id-ReferenceGeometry", false).isPartition();
+        this._ReferenceGeometry_shapes = new Reference(this._ReferenceGeometry, "shapes", "key-shapes-references", "id-shape-references").isOptional().isMultiple();
+        this._Documentation = new Annotation(this._language, "Documentation", "key-Documentation", "id-Documentation");
+        this._Documentation_text = new Property(this._Documentation, "text", "key-text", "id-text").isOptional();
+        this._Documentation_technical = new Property(this._Documentation, "technical", "key-technical", "id-technical").isOptional();
+        this._BillOfMaterials = new Annotation(this._language, "BillOfMaterials", "key-BillOfMaterials", "id-BillOfMaterials");
+        this._BillOfMaterials_materials = new Reference(this._BillOfMaterials, "materials", "key-materials", "id-materials").isOptional().isMultiple();
+        this._BillOfMaterials_groups = new Containment(this._BillOfMaterials, "groups", "key-groups", "id-groups").isOptional().isMultiple();
+        this._BillOfMaterials_altGroups = new Containment(this._BillOfMaterials, "altGroups", "key-alt-groups", "id-alt-groups").isOptional().isMultiple();
+        this._BillOfMaterials_defaultGroup = new Containment(this._BillOfMaterials, "defaultGroup", "key-default-group", "id-default-group").isOptional();
+        this._MaterialGroup = new Concept(this._language, "MaterialGroup", "key-MaterialGroup", "id-MaterialGroup", false);
+        this._MaterialGroup_matterState = new Property(this._MaterialGroup, "matterState", "key-matter-state", "id-matter-state").isOptional();
+        this._MaterialGroup_materials = new Reference(this._MaterialGroup, "materials", "key-group-materials", "id-group-materials").isMultiple();
+        this._MaterialGroup_defaultShape = new Containment(this._MaterialGroup, "defaultShape", "key-default-shape", "id-default-shape").isOptional();
+        this._MatterState = new Enumeration(this._language, "MatterState", "key-MatterState", "id-MatterState");
+        this._MatterState_solid = new EnumerationLiteral(this._MatterState, "solid", "key-solid", "id-solid");
+        this._MatterState_liquid = new EnumerationLiteral(this._MatterState, "liquid", "key-liquid", "id-liquid");
+        this._MatterState_gas = new EnumerationLiteral(this._MatterState, "gas", "key-gas", "id-gas");
+        this._Time = new PrimitiveType(this._language, "Time", "key-Time", "id-Time");
+        this._wiredUp = false;
+    }
+    get language() {
+        this.ensureWiredUp();
+        return this._language;
+    }
+    get Circle() {
+        this.ensureWiredUp();
+        return this._Circle;
+    }
+    get Circle_r() {
+        this.ensureWiredUp();
+        return this._Circle_r;
+    }
+    get Circle_center() {
+        this.ensureWiredUp();
+        return this._Circle_center;
+    }
+    get Coord() {
+        this.ensureWiredUp();
+        return this._Coord;
+    }
+    get Coord_x() {
+        this.ensureWiredUp();
+        return this._Coord_x;
+    }
+    get Coord_y() {
+        this.ensureWiredUp();
+        return this._Coord_y;
+    }
+    get Coord_z() {
+        this.ensureWiredUp();
+        return this._Coord_z;
+    }
+    get Geometry() {
+        this.ensureWiredUp();
+        return this._Geometry;
+    }
+    get Geometry_shapes() {
+        this.ensureWiredUp();
+        return this._Geometry_shapes;
+    }
+    get Geometry_documentation() {
+        this.ensureWiredUp();
+        return this._Geometry_documentation;
+    }
+    get IShape() {
+        this.ensureWiredUp();
+        return this._IShape;
+    }
+    get IShape_uuid() {
+        this.ensureWiredUp();
+        return this._IShape_uuid;
+    }
+    get IShape_fixpoints() {
+        this.ensureWiredUp();
+        return this._IShape_fixpoints;
+    }
+    get Line() {
+        this.ensureWiredUp();
+        return this._Line;
+    }
+    get Line_start() {
+        this.ensureWiredUp();
+        return this._Line_start;
+    }
+    get Line_end() {
+        this.ensureWiredUp();
+        return this._Line_end;
+    }
+    get OffsetDuplicate() {
+        this.ensureWiredUp();
+        return this._OffsetDuplicate;
+    }
+    get OffsetDuplicate_offset() {
+        this.ensureWiredUp();
+        return this._OffsetDuplicate_offset;
+    }
+    get OffsetDuplicate_source() {
+        this.ensureWiredUp();
+        return this._OffsetDuplicate_source;
+    }
+    get OffsetDuplicate_altSource() {
+        this.ensureWiredUp();
+        return this._OffsetDuplicate_altSource;
+    }
+    get OffsetDuplicate_docs() {
+        this.ensureWiredUp();
+        return this._OffsetDuplicate_docs;
+    }
+    get OffsetDuplicate_secretDocs() {
+        this.ensureWiredUp();
+        return this._OffsetDuplicate_secretDocs;
+    }
+    get Shape() {
+        this.ensureWiredUp();
+        return this._Shape;
+    }
+    get Shape_shapeDocs() {
+        this.ensureWiredUp();
+        return this._Shape_shapeDocs;
+    }
+    get CompositeShape() {
+        this.ensureWiredUp();
+        return this._CompositeShape;
+    }
+    get CompositeShape_parts() {
+        this.ensureWiredUp();
+        return this._CompositeShape_parts;
+    }
+    get CompositeShape_disabledParts() {
+        this.ensureWiredUp();
+        return this._CompositeShape_disabledParts;
+    }
+    get CompositeShape_evilPart() {
+        this.ensureWiredUp();
+        return this._CompositeShape_evilPart;
+    }
+    get ReferenceGeometry() {
+        this.ensureWiredUp();
+        return this._ReferenceGeometry;
+    }
+    get ReferenceGeometry_shapes() {
+        this.ensureWiredUp();
+        return this._ReferenceGeometry_shapes;
+    }
+    get Documentation() {
+        this.ensureWiredUp();
+        return this._Documentation;
+    }
+    get Documentation_text() {
+        this.ensureWiredUp();
+        return this._Documentation_text;
+    }
+    get Documentation_technical() {
+        this.ensureWiredUp();
+        return this._Documentation_technical;
+    }
+    get BillOfMaterials() {
+        this.ensureWiredUp();
+        return this._BillOfMaterials;
+    }
+    get BillOfMaterials_materials() {
+        this.ensureWiredUp();
+        return this._BillOfMaterials_materials;
+    }
+    get BillOfMaterials_groups() {
+        this.ensureWiredUp();
+        return this._BillOfMaterials_groups;
+    }
+    get BillOfMaterials_altGroups() {
+        this.ensureWiredUp();
+        return this._BillOfMaterials_altGroups;
+    }
+    get BillOfMaterials_defaultGroup() {
+        this.ensureWiredUp();
+        return this._BillOfMaterials_defaultGroup;
+    }
+    get MaterialGroup() {
+        this.ensureWiredUp();
+        return this._MaterialGroup;
+    }
+    get MaterialGroup_matterState() {
+        this.ensureWiredUp();
+        return this._MaterialGroup_matterState;
+    }
+    get MaterialGroup_materials() {
+        this.ensureWiredUp();
+        return this._MaterialGroup_materials;
+    }
+    get MaterialGroup_defaultShape() {
+        this.ensureWiredUp();
+        return this._MaterialGroup_defaultShape;
+    }
+    get MatterState() {
+        this.ensureWiredUp();
+        return this._MatterState;
+    }
+    get MatterState_solid() {
+        this.ensureWiredUp();
+        return this._MatterState_solid;
+    }
+    get MatterState_liquid() {
+        this.ensureWiredUp();
+        return this._MatterState_liquid;
+    }
+    get MatterState_gas() {
+        this.ensureWiredUp();
+        return this._MatterState_gas;
+    }
+    get Time() {
+        this.ensureWiredUp();
+        return this._Time;
+    }
+    ensureWiredUp() {
+        if (this._wiredUp) {
+            return;
+        }
+        this._language.havingEntities(this._Circle, this._Coord, this._Geometry, this._IShape, this._Line, this._OffsetDuplicate, this._Shape, this._CompositeShape, this._ReferenceGeometry, this._Documentation, this._BillOfMaterials, this._MaterialGroup, this._MatterState, this._Time);
+        this._Circle.extends = this._Shape;
+        this._Circle.havingFeatures(this._Circle_r, this._Circle_center);
+        this._Circle_r.ofType(LionCore_builtinsBase.INSTANCE._Integer);
+        this._Circle_center.ofType(this._Coord);
+        this._Coord.havingFeatures(this._Coord_x, this._Coord_y, this._Coord_z);
+        this._Coord_x.ofType(LionCore_builtinsBase.INSTANCE._Integer);
+        this._Coord_y.ofType(LionCore_builtinsBase.INSTANCE._Integer);
+        this._Coord_z.ofType(LionCore_builtinsBase.INSTANCE._Integer);
+        this._Geometry.havingFeatures(this._Geometry_shapes, this._Geometry_documentation);
+        this._Geometry_shapes.ofType(this._IShape);
+        this._Geometry_documentation.ofType(this._Documentation);
+        this._IShape.havingFeatures(this._IShape_uuid, this._IShape_fixpoints);
+        this._IShape_uuid.ofType(LionCore_builtinsBase.INSTANCE._String);
+        this._IShape_fixpoints.ofType(this._Coord);
+        this._Line.extends = this._Shape;
+        this._Line.implementing(LionCore_builtinsBase.INSTANCE._INamed);
+        this._Line.havingFeatures(this._Line_start, this._Line_end);
+        this._Line_start.ofType(this._Coord);
+        this._Line_end.ofType(this._Coord);
+        this._OffsetDuplicate.extends = this._Shape;
+        this._OffsetDuplicate.havingFeatures(this._OffsetDuplicate_offset, this._OffsetDuplicate_source, this._OffsetDuplicate_altSource, this._OffsetDuplicate_docs, this._OffsetDuplicate_secretDocs);
+        this._OffsetDuplicate_offset.ofType(this._Coord);
+        this._OffsetDuplicate_source.ofType(this._Shape);
+        this._OffsetDuplicate_altSource.ofType(this._Shape);
+        this._OffsetDuplicate_docs.ofType(this._Documentation);
+        this._OffsetDuplicate_secretDocs.ofType(this._Documentation);
+        this._Shape.implementing(LionCore_builtinsBase.INSTANCE._INamed, this._IShape);
+        this._Shape.havingFeatures(this._Shape_shapeDocs);
+        this._Shape_shapeDocs.ofType(this._Documentation);
+        this._CompositeShape.extends = this._Shape;
+        this._CompositeShape.havingFeatures(this._CompositeShape_parts, this._CompositeShape_disabledParts, this._CompositeShape_evilPart);
+        this._CompositeShape_parts.ofType(this._IShape);
+        this._CompositeShape_disabledParts.ofType(this._IShape);
+        this._CompositeShape_evilPart.ofType(this._IShape);
+        this._ReferenceGeometry.havingFeatures(this._ReferenceGeometry_shapes);
+        this._ReferenceGeometry_shapes.ofType(this._IShape);
+        this._Documentation.havingFeatures(this._Documentation_text, this._Documentation_technical);
+        this._Documentation_text.ofType(LionCore_builtinsBase.INSTANCE._String).isOptional();
+        this._Documentation_technical.ofType(LionCore_builtinsBase.INSTANCE._Boolean).isOptional();
+        this._BillOfMaterials.havingFeatures(this._BillOfMaterials_materials, this._BillOfMaterials_groups, this._BillOfMaterials_altGroups, this._BillOfMaterials_defaultGroup);
+        this._BillOfMaterials_materials.ofType(this._IShape);
+        this._BillOfMaterials_groups.ofType(this._MaterialGroup);
+        this._BillOfMaterials_altGroups.ofType(this._MaterialGroup);
+        this._BillOfMaterials_defaultGroup.ofType(this._MaterialGroup);
+        this._MaterialGroup.havingFeatures(this._MaterialGroup_matterState, this._MaterialGroup_materials, this._MaterialGroup_defaultShape);
+        this._MaterialGroup_matterState.ofType(this._MatterState).isOptional();
+        this._MaterialGroup_materials.ofType(this._IShape);
+        this._MaterialGroup_defaultShape.ofType(this._IShape);
+        this._MatterState.havingLiterals(this._MatterState_solid, this._MatterState_liquid, this._MatterState_gas);
+        this._wiredUp = true;
+    }
+    factory(handleDelta) {
+        return (classifier, id) => {
+            switch (classifier.key) {
+                case this._Circle.key: return Circle.create(id, handleDelta);
+                case this._Coord.key: return Coord.create(id, handleDelta);
+                case this._Geometry.key: return Geometry.create(id, handleDelta);
+                case this._Line.key: return Line.create(id, handleDelta);
+                case this._OffsetDuplicate.key: return OffsetDuplicate.create(id, handleDelta);
+                case this._CompositeShape.key: return CompositeShape.create(id, handleDelta);
+                case this._ReferenceGeometry.key: return ReferenceGeometry.create(id, handleDelta);
+                case this._Documentation.key: return Documentation.create(id, handleDelta);
+                case this._BillOfMaterials.key: return BillOfMaterials.create(id, handleDelta);
+                case this._MaterialGroup.key: return MaterialGroup.create(id, handleDelta);
+                default: {
+                    const { language } = classifier;
+                    throw new Error(`can't instantiate ${classifier.name} (key=${classifier.key}): classifier is not known in language ${language.name} (key=${language.key}, version=${language.version})`);
+                }
+            }
+        };
+    }
+    enumLiteralFrom(enumerationLiteral) {
+        const { enumeration } = enumerationLiteral;
+        if (enumeration.key === this._MatterState.key) {
+            return enumerationLiteral.key;
+        }
+        const { language } = enumeration;
+        throw new Error(`enumeration with key ${enumeration.key} is not known in language ${language.name} (key=${language.key}, version=${language.version})`);
+    }
+}
+ShapesBase.INSTANCE = new ShapesBase();
+export class Shape extends NodeBase {
+    get shapeDocs() {
+        return this._shapeDocs.get();
+    }
+    set shapeDocs(newValue) {
+        this._shapeDocs.set(newValue);
+    }
+    replaceShapeDocsWith(newValue) {
+        this._shapeDocs.replaceWith(newValue);
+    }
+    get name() {
+        return this._name.get();
+    }
+    set name(newValue) {
+        this._name.set(newValue);
+    }
+    get uuid() {
+        return this._uuid.get();
+    }
+    set uuid(newValue) {
+        this._uuid.set(newValue);
+    }
+    get fixpoints() {
+        return this._fixpoints.get();
+    }
+    addFixpoints(newValue) {
+        this._fixpoints.add(newValue);
+    }
+    removeFixpoints(valueToRemove) {
+        this._fixpoints.remove(valueToRemove);
+    }
+    addFixpointsAtIndex(newValue, index) {
+        this._fixpoints.insertAtIndex(newValue, index);
+    }
+    moveFixpoints(oldIndex, newIndex) {
+        this._fixpoints.move(oldIndex, newIndex);
+    }
+    replaceFixpointsAtIndex(movedChild, newIndex) {
+        this._fixpoints.replaceAtIndex(movedChild, newIndex);
+    }
+    constructor(classifier, id, handleDelta, parentInfo) {
+        super(classifier, id, handleDelta, parentInfo);
+        this._shapeDocs = new OptionalSingleContainmentValueManager(ShapesBase.INSTANCE.Shape_shapeDocs, this);
+        this._name = new RequiredPropertyValueManager(LionCore_builtinsBase.INSTANCE.INamed_name, this);
+        this._uuid = new RequiredPropertyValueManager(ShapesBase.INSTANCE.IShape_uuid, this);
+        this._fixpoints = new OptionalMultiContainmentValueManager(ShapesBase.INSTANCE.IShape_fixpoints, this);
+    }
+    getPropertyValueManager(property) {
+        switch (property.key) {
+            case LionCore_builtinsBase.INSTANCE.INamed_name.key: return this._name;
+            case ShapesBase.INSTANCE.IShape_uuid.key: return this._uuid;
+            default: return super.getPropertyValueManager(property);
+        }
+    }
+    getContainmentValueManager(containment) {
+        switch (containment.key) {
+            case ShapesBase.INSTANCE.Shape_shapeDocs.key: return this._shapeDocs;
+            case ShapesBase.INSTANCE.IShape_fixpoints.key: return this._fixpoints;
+            default: return super.getContainmentValueManager(containment);
+        }
+    }
+}
+export class Circle extends Shape {
+    static create(id, handleDelta, parentInfo) {
+        return new Circle(ShapesBase.INSTANCE.Circle, id, handleDelta, parentInfo);
+    }
+    get r() {
+        return this._r.get();
+    }
+    set r(newValue) {
+        this._r.set(newValue);
+    }
+    get center() {
+        return this._center.get();
+    }
+    set center(newValue) {
+        this._center.set(newValue);
+    }
+    replaceCenterWith(newValue) {
+        this._center.replaceWith(newValue);
+    }
+    constructor(classifier, id, handleDelta, parentInfo) {
+        super(classifier, id, handleDelta, parentInfo);
+        this._r = new RequiredPropertyValueManager(ShapesBase.INSTANCE.Circle_r, this);
+        this._center = new RequiredSingleContainmentValueManager(ShapesBase.INSTANCE.Circle_center, this);
+    }
+    getPropertyValueManager(property) {
+        if (property.key === ShapesBase.INSTANCE.Circle_r.key) {
+            return this._r;
+        }
+        return super.getPropertyValueManager(property);
+    }
+    getContainmentValueManager(containment) {
+        if (containment.key === ShapesBase.INSTANCE.Circle_center.key) {
+            return this._center;
+        }
+        return super.getContainmentValueManager(containment);
+    }
+}
+export class Coord extends NodeBase {
+    static create(id, handleDelta, parentInfo) {
+        return new Coord(ShapesBase.INSTANCE.Coord, id, handleDelta, parentInfo);
+    }
+    get x() {
+        return this._x.get();
+    }
+    set x(newValue) {
+        this._x.set(newValue);
+    }
+    get y() {
+        return this._y.get();
+    }
+    set y(newValue) {
+        this._y.set(newValue);
+    }
+    get z() {
+        return this._z.get();
+    }
+    set z(newValue) {
+        this._z.set(newValue);
+    }
+    constructor(classifier, id, handleDelta, parentInfo) {
+        super(classifier, id, handleDelta, parentInfo);
+        this._x = new RequiredPropertyValueManager(ShapesBase.INSTANCE.Coord_x, this);
+        this._y = new RequiredPropertyValueManager(ShapesBase.INSTANCE.Coord_y, this);
+        this._z = new RequiredPropertyValueManager(ShapesBase.INSTANCE.Coord_z, this);
+    }
+    getPropertyValueManager(property) {
+        switch (property.key) {
+            case ShapesBase.INSTANCE.Coord_x.key: return this._x;
+            case ShapesBase.INSTANCE.Coord_y.key: return this._y;
+            case ShapesBase.INSTANCE.Coord_z.key: return this._z;
+            default: return super.getPropertyValueManager(property);
+        }
+    }
+}
+export class Geometry extends NodeBase {
+    static create(id, handleDelta, parentInfo) {
+        return new Geometry(ShapesBase.INSTANCE.Geometry, id, handleDelta, parentInfo);
+    }
+    get shapes() {
+        return this._shapes.get();
+    }
+    addShapes(newValue) {
+        this._shapes.add(newValue);
+    }
+    removeShapes(valueToRemove) {
+        this._shapes.remove(valueToRemove);
+    }
+    addShapesAtIndex(newValue, index) {
+        this._shapes.insertAtIndex(newValue, index);
+    }
+    moveShapes(oldIndex, newIndex) {
+        this._shapes.move(oldIndex, newIndex);
+    }
+    replaceShapesAtIndex(movedChild, newIndex) {
+        this._shapes.replaceAtIndex(movedChild, newIndex);
+    }
+    get documentation() {
+        return this._documentation.get();
+    }
+    set documentation(newValue) {
+        this._documentation.set(newValue);
+    }
+    replaceDocumentationWith(newValue) {
+        this._documentation.replaceWith(newValue);
+    }
+    constructor(classifier, id, handleDelta, parentInfo) {
+        super(classifier, id, handleDelta, parentInfo);
+        this._shapes = new OptionalMultiContainmentValueManager(ShapesBase.INSTANCE.Geometry_shapes, this);
+        this._documentation = new OptionalSingleContainmentValueManager(ShapesBase.INSTANCE.Geometry_documentation, this);
+    }
+    getContainmentValueManager(containment) {
+        switch (containment.key) {
+            case ShapesBase.INSTANCE.Geometry_shapes.key: return this._shapes;
+            case ShapesBase.INSTANCE.Geometry_documentation.key: return this._documentation;
+            default: return super.getContainmentValueManager(containment);
+        }
+    }
+}
+export class Line extends Shape {
+    static create(id, handleDelta, parentInfo) {
+        return new Line(ShapesBase.INSTANCE.Line, id, handleDelta, parentInfo);
+    }
+    get start() {
+        return this._start.get();
+    }
+    set start(newValue) {
+        this._start.set(newValue);
+    }
+    replaceStartWith(newValue) {
+        this._start.replaceWith(newValue);
+    }
+    get end() {
+        return this._end.get();
+    }
+    set end(newValue) {
+        this._end.set(newValue);
+    }
+    replaceEndWith(newValue) {
+        this._end.replaceWith(newValue);
+    }
+    constructor(classifier, id, handleDelta, parentInfo) {
+        super(classifier, id, handleDelta, parentInfo);
+        this._start = new RequiredSingleContainmentValueManager(ShapesBase.INSTANCE.Line_start, this);
+        this._end = new RequiredSingleContainmentValueManager(ShapesBase.INSTANCE.Line_end, this);
+    }
+    getContainmentValueManager(containment) {
+        switch (containment.key) {
+            case ShapesBase.INSTANCE.Line_start.key: return this._start;
+            case ShapesBase.INSTANCE.Line_end.key: return this._end;
+            default: return super.getContainmentValueManager(containment);
+        }
+    }
+}
+export class OffsetDuplicate extends Shape {
+    static create(id, handleDelta, parentInfo) {
+        return new OffsetDuplicate(ShapesBase.INSTANCE.OffsetDuplicate, id, handleDelta, parentInfo);
+    }
+    get offset() {
+        return this._offset.get();
+    }
+    set offset(newValue) {
+        this._offset.set(newValue);
+    }
+    replaceOffsetWith(newValue) {
+        this._offset.replaceWith(newValue);
+    }
+    get source() {
+        return this._source.get();
+    }
+    set source(newValue) {
+        this._source.set(newValue);
+    }
+    get altSource() {
+        return this._altSource.get();
+    }
+    set altSource(newValue) {
+        this._altSource.set(newValue);
+    }
+    get docs() {
+        return this._docs.get();
+    }
+    set docs(newValue) {
+        this._docs.set(newValue);
+    }
+    replaceDocsWith(newValue) {
+        this._docs.replaceWith(newValue);
+    }
+    get secretDocs() {
+        return this._secretDocs.get();
+    }
+    set secretDocs(newValue) {
+        this._secretDocs.set(newValue);
+    }
+    replaceSecretDocsWith(newValue) {
+        this._secretDocs.replaceWith(newValue);
+    }
+    constructor(classifier, id, handleDelta, parentInfo) {
+        super(classifier, id, handleDelta, parentInfo);
+        this._offset = new RequiredSingleContainmentValueManager(ShapesBase.INSTANCE.OffsetDuplicate_offset, this);
+        this._source = new RequiredSingleReferenceValueManager(ShapesBase.INSTANCE.OffsetDuplicate_source, this);
+        this._altSource = new OptionalSingleReferenceValueManager(ShapesBase.INSTANCE.OffsetDuplicate_altSource, this);
+        this._docs = new OptionalSingleContainmentValueManager(ShapesBase.INSTANCE.OffsetDuplicate_docs, this);
+        this._secretDocs = new OptionalSingleContainmentValueManager(ShapesBase.INSTANCE.OffsetDuplicate_secretDocs, this);
+    }
+    getContainmentValueManager(containment) {
+        switch (containment.key) {
+            case ShapesBase.INSTANCE.OffsetDuplicate_offset.key: return this._offset;
+            case ShapesBase.INSTANCE.OffsetDuplicate_docs.key: return this._docs;
+            case ShapesBase.INSTANCE.OffsetDuplicate_secretDocs.key: return this._secretDocs;
+            default: return super.getContainmentValueManager(containment);
+        }
+    }
+    getReferenceValueManager(reference) {
+        switch (reference.key) {
+            case ShapesBase.INSTANCE.OffsetDuplicate_source.key: return this._source;
+            case ShapesBase.INSTANCE.OffsetDuplicate_altSource.key: return this._altSource;
+            default: return super.getReferenceValueManager(reference);
+        }
+    }
+}
+export class CompositeShape extends Shape {
+    static create(id, handleDelta, parentInfo) {
+        return new CompositeShape(ShapesBase.INSTANCE.CompositeShape, id, handleDelta, parentInfo);
+    }
+    get parts() {
+        return this._parts.get();
+    }
+    addParts(newValue) {
+        this._parts.add(newValue);
+    }
+    removeParts(valueToRemove) {
+        this._parts.remove(valueToRemove);
+    }
+    addPartsAtIndex(newValue, index) {
+        this._parts.insertAtIndex(newValue, index);
+    }
+    moveParts(oldIndex, newIndex) {
+        this._parts.move(oldIndex, newIndex);
+    }
+    replacePartsAtIndex(movedChild, newIndex) {
+        this._parts.replaceAtIndex(movedChild, newIndex);
+    }
+    get disabledParts() {
+        return this._disabledParts.get();
+    }
+    addDisabledParts(newValue) {
+        this._disabledParts.add(newValue);
+    }
+    removeDisabledParts(valueToRemove) {
+        this._disabledParts.remove(valueToRemove);
+    }
+    addDisabledPartsAtIndex(newValue, index) {
+        this._disabledParts.insertAtIndex(newValue, index);
+    }
+    moveDisabledParts(oldIndex, newIndex) {
+        this._disabledParts.move(oldIndex, newIndex);
+    }
+    replaceDisabledPartsAtIndex(movedChild, newIndex) {
+        this._disabledParts.replaceAtIndex(movedChild, newIndex);
+    }
+    get evilPart() {
+        return this._evilPart.get();
+    }
+    set evilPart(newValue) {
+        this._evilPart.set(newValue);
+    }
+    replaceEvilPartWith(newValue) {
+        this._evilPart.replaceWith(newValue);
+    }
+    constructor(classifier, id, handleDelta, parentInfo) {
+        super(classifier, id, handleDelta, parentInfo);
+        this._parts = new RequiredMultiContainmentValueManager(ShapesBase.INSTANCE.CompositeShape_parts, this);
+        this._disabledParts = new RequiredMultiContainmentValueManager(ShapesBase.INSTANCE.CompositeShape_disabledParts, this);
+        this._evilPart = new RequiredSingleContainmentValueManager(ShapesBase.INSTANCE.CompositeShape_evilPart, this);
+    }
+    getContainmentValueManager(containment) {
+        switch (containment.key) {
+            case ShapesBase.INSTANCE.CompositeShape_parts.key: return this._parts;
+            case ShapesBase.INSTANCE.CompositeShape_disabledParts.key: return this._disabledParts;
+            case ShapesBase.INSTANCE.CompositeShape_evilPart.key: return this._evilPart;
+            default: return super.getContainmentValueManager(containment);
+        }
+    }
+}
+export class ReferenceGeometry extends NodeBase {
+    static create(id, handleDelta, parentInfo) {
+        return new ReferenceGeometry(ShapesBase.INSTANCE.ReferenceGeometry, id, handleDelta, parentInfo);
+    }
+    get shapes() {
+        return this._shapes.get();
+    }
+    addShapes(newValue) {
+        this._shapes.add(newValue);
+    }
+    removeShapes(valueToRemove) {
+        this._shapes.remove(valueToRemove);
+    }
+    addShapesAtIndex(newValue, index) {
+        this._shapes.insertAtIndex(newValue, index);
+    }
+    moveShapes(oldIndex, newIndex) {
+        this._shapes.move(oldIndex, newIndex);
+    }
+    constructor(classifier, id, handleDelta, parentInfo) {
+        super(classifier, id, handleDelta, parentInfo);
+        this._shapes = new OptionalMultiReferenceValueManager(ShapesBase.INSTANCE.ReferenceGeometry_shapes, this);
+    }
+    getReferenceValueManager(reference) {
+        if (reference.key === ShapesBase.INSTANCE.ReferenceGeometry_shapes.key) {
+            return this._shapes;
+        }
+        return super.getReferenceValueManager(reference);
+    }
+}
+export class Documentation extends NodeBase {
+    static create(id, handleDelta, parentInfo) {
+        return new Documentation(ShapesBase.INSTANCE.Documentation, id, handleDelta, parentInfo);
+    }
+    get text() {
+        return this._text.get();
+    }
+    set text(newValue) {
+        this._text.set(newValue);
+    }
+    get technical() {
+        return this._technical.get();
+    }
+    set technical(newValue) {
+        this._technical.set(newValue);
+    }
+    constructor(classifier, id, handleDelta, parentInfo) {
+        super(classifier, id, handleDelta, parentInfo);
+        this._text = new OptionalPropertyValueManager(ShapesBase.INSTANCE.Documentation_text, this);
+        this._technical = new OptionalPropertyValueManager(ShapesBase.INSTANCE.Documentation_technical, this);
+    }
+    getPropertyValueManager(property) {
+        switch (property.key) {
+            case ShapesBase.INSTANCE.Documentation_text.key: return this._text;
+            case ShapesBase.INSTANCE.Documentation_technical.key: return this._technical;
+            default: return super.getPropertyValueManager(property);
+        }
+    }
+}
+export class BillOfMaterials extends NodeBase {
+    static create(id, handleDelta, parentInfo) {
+        return new BillOfMaterials(ShapesBase.INSTANCE.BillOfMaterials, id, handleDelta, parentInfo);
+    }
+    get materials() {
+        return this._materials.get();
+    }
+    addMaterials(newValue) {
+        this._materials.add(newValue);
+    }
+    removeMaterials(valueToRemove) {
+        this._materials.remove(valueToRemove);
+    }
+    addMaterialsAtIndex(newValue, index) {
+        this._materials.insertAtIndex(newValue, index);
+    }
+    moveMaterials(oldIndex, newIndex) {
+        this._materials.move(oldIndex, newIndex);
+    }
+    get groups() {
+        return this._groups.get();
+    }
+    addGroups(newValue) {
+        this._groups.add(newValue);
+    }
+    removeGroups(valueToRemove) {
+        this._groups.remove(valueToRemove);
+    }
+    addGroupsAtIndex(newValue, index) {
+        this._groups.insertAtIndex(newValue, index);
+    }
+    moveGroups(oldIndex, newIndex) {
+        this._groups.move(oldIndex, newIndex);
+    }
+    replaceGroupsAtIndex(movedChild, newIndex) {
+        this._groups.replaceAtIndex(movedChild, newIndex);
+    }
+    get altGroups() {
+        return this._altGroups.get();
+    }
+    addAltGroups(newValue) {
+        this._altGroups.add(newValue);
+    }
+    removeAltGroups(valueToRemove) {
+        this._altGroups.remove(valueToRemove);
+    }
+    addAltGroupsAtIndex(newValue, index) {
+        this._altGroups.insertAtIndex(newValue, index);
+    }
+    moveAltGroups(oldIndex, newIndex) {
+        this._altGroups.move(oldIndex, newIndex);
+    }
+    replaceAltGroupsAtIndex(movedChild, newIndex) {
+        this._altGroups.replaceAtIndex(movedChild, newIndex);
+    }
+    get defaultGroup() {
+        return this._defaultGroup.get();
+    }
+    set defaultGroup(newValue) {
+        this._defaultGroup.set(newValue);
+    }
+    replaceDefaultGroupWith(newValue) {
+        this._defaultGroup.replaceWith(newValue);
+    }
+    constructor(classifier, id, handleDelta, parentInfo) {
+        super(classifier, id, handleDelta, parentInfo);
+        this._materials = new OptionalMultiReferenceValueManager(ShapesBase.INSTANCE.BillOfMaterials_materials, this);
+        this._groups = new OptionalMultiContainmentValueManager(ShapesBase.INSTANCE.BillOfMaterials_groups, this);
+        this._altGroups = new OptionalMultiContainmentValueManager(ShapesBase.INSTANCE.BillOfMaterials_altGroups, this);
+        this._defaultGroup = new OptionalSingleContainmentValueManager(ShapesBase.INSTANCE.BillOfMaterials_defaultGroup, this);
+    }
+    getContainmentValueManager(containment) {
+        switch (containment.key) {
+            case ShapesBase.INSTANCE.BillOfMaterials_groups.key: return this._groups;
+            case ShapesBase.INSTANCE.BillOfMaterials_altGroups.key: return this._altGroups;
+            case ShapesBase.INSTANCE.BillOfMaterials_defaultGroup.key: return this._defaultGroup;
+            default: return super.getContainmentValueManager(containment);
+        }
+    }
+    getReferenceValueManager(reference) {
+        if (reference.key === ShapesBase.INSTANCE.BillOfMaterials_materials.key) {
+            return this._materials;
+        }
+        return super.getReferenceValueManager(reference);
+    }
+}
+export class MaterialGroup extends NodeBase {
+    static create(id, handleDelta, parentInfo) {
+        return new MaterialGroup(ShapesBase.INSTANCE.MaterialGroup, id, handleDelta, parentInfo);
+    }
+    get matterState() {
+        return this._matterState.get();
+    }
+    set matterState(newValue) {
+        this._matterState.set(newValue);
+    }
+    get materials() {
+        return this._materials.get();
+    }
+    addMaterials(newValue) {
+        this._materials.add(newValue);
+    }
+    removeMaterials(valueToRemove) {
+        this._materials.remove(valueToRemove);
+    }
+    addMaterialsAtIndex(newValue, index) {
+        this._materials.insertAtIndex(newValue, index);
+    }
+    moveMaterials(oldIndex, newIndex) {
+        this._materials.move(oldIndex, newIndex);
+    }
+    get defaultShape() {
+        return this._defaultShape.get();
+    }
+    set defaultShape(newValue) {
+        this._defaultShape.set(newValue);
+    }
+    replaceDefaultShapeWith(newValue) {
+        this._defaultShape.replaceWith(newValue);
+    }
+    constructor(classifier, id, handleDelta, parentInfo) {
+        super(classifier, id, handleDelta, parentInfo);
+        this._matterState = new OptionalPropertyValueManager(ShapesBase.INSTANCE.MaterialGroup_matterState, this);
+        this._materials = new RequiredMultiReferenceValueManager(ShapesBase.INSTANCE.MaterialGroup_materials, this);
+        this._defaultShape = new OptionalSingleContainmentValueManager(ShapesBase.INSTANCE.MaterialGroup_defaultShape, this);
+    }
+    getPropertyValueManager(property) {
+        if (property.key === ShapesBase.INSTANCE.MaterialGroup_matterState.key) {
+            return this._matterState;
+        }
+        return super.getPropertyValueManager(property);
+    }
+    getContainmentValueManager(containment) {
+        if (containment.key === ShapesBase.INSTANCE.MaterialGroup_defaultShape.key) {
+            return this._defaultShape;
+        }
+        return super.getContainmentValueManager(containment);
+    }
+    getReferenceValueManager(reference) {
+        if (reference.key === ShapesBase.INSTANCE.MaterialGroup_materials.key) {
+            return this._materials;
+        }
+        return super.getReferenceValueManager(reference);
+    }
+}
+export var MatterState;
+(function (MatterState) {
+    MatterState["solid"] = "key-solid";
+    MatterState["liquid"] = "key-liquid";
+    MatterState["gas"] = "key-gas";
+})(MatterState || (MatterState = {}));
+//# sourceMappingURL=Shapes.g.js.map