inhumate-rti 0.0.26

package/lib/generated/Geometry.js

@@ -0,0 +1,1427 @@
+import _m0 from "protobufjs/minimal.js";
+import { Color } from "./Color.js";
+export const protobufPackage = "inhumate.rti.proto";
+export var Geometry_Usage;
+(function (Geometry_Usage) {
+    Geometry_Usage[Geometry_Usage["SCENARIO"] = 0] = "SCENARIO";
+    Geometry_Usage[Geometry_Usage["ENTITY"] = 1] = "ENTITY";
+    Geometry_Usage[Geometry_Usage["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(Geometry_Usage || (Geometry_Usage = {}));
+export function geometry_UsageFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "SCENARIO":
+            return Geometry_Usage.SCENARIO;
+        case 1:
+        case "ENTITY":
+            return Geometry_Usage.ENTITY;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return Geometry_Usage.UNRECOGNIZED;
+    }
+}
+export function geometry_UsageToJSON(object) {
+    switch (object) {
+        case Geometry_Usage.SCENARIO:
+            return "SCENARIO";
+        case Geometry_Usage.ENTITY:
+            return "ENTITY";
+        case Geometry_Usage.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+export var Geometry_Category;
+(function (Geometry_Category) {
+    Geometry_Category[Geometry_Category["UNKNOWN_GEOMETRY"] = 0] = "UNKNOWN_GEOMETRY";
+    Geometry_Category[Geometry_Category["PHYSICAL_GEOMETRY"] = 10] = "PHYSICAL_GEOMETRY";
+    Geometry_Category[Geometry_Category["GROUND"] = 11] = "GROUND";
+    Geometry_Category[Geometry_Category["VEGETATION"] = 12] = "VEGETATION";
+    Geometry_Category[Geometry_Category["STRUCTURE"] = 13] = "STRUCTURE";
+    Geometry_Category[Geometry_Category["ROAD"] = 14] = "ROAD";
+    Geometry_Category[Geometry_Category["ABSTRACT_GEOMETRY"] = 100] = "ABSTRACT_GEOMETRY";
+    Geometry_Category[Geometry_Category["ZONE"] = 101] = "ZONE";
+    Geometry_Category[Geometry_Category["TRIGGER"] = 102] = "TRIGGER";
+    Geometry_Category[Geometry_Category["EDGE"] = 103] = "EDGE";
+    Geometry_Category[Geometry_Category["PATH"] = 104] = "PATH";
+    Geometry_Category[Geometry_Category["PLANNED_PATH"] = 105] = "PLANNED_PATH";
+    Geometry_Category[Geometry_Category["HISTORIC_PATH"] = 106] = "HISTORIC_PATH";
+    Geometry_Category[Geometry_Category["SENSOR_COVERAGE"] = 151] = "SENSOR_COVERAGE";
+    Geometry_Category[Geometry_Category["SENSOR_HIT"] = 152] = "SENSOR_HIT";
+    Geometry_Category[Geometry_Category["DEBUG_GEOMETRY"] = 200] = "DEBUG_GEOMETRY";
+    Geometry_Category[Geometry_Category["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(Geometry_Category || (Geometry_Category = {}));
+export function geometry_CategoryFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "UNKNOWN_GEOMETRY":
+            return Geometry_Category.UNKNOWN_GEOMETRY;
+        case 10:
+        case "PHYSICAL_GEOMETRY":
+            return Geometry_Category.PHYSICAL_GEOMETRY;
+        case 11:
+        case "GROUND":
+            return Geometry_Category.GROUND;
+        case 12:
+        case "VEGETATION":
+            return Geometry_Category.VEGETATION;
+        case 13:
+        case "STRUCTURE":
+            return Geometry_Category.STRUCTURE;
+        case 14:
+        case "ROAD":
+            return Geometry_Category.ROAD;
+        case 100:
+        case "ABSTRACT_GEOMETRY":
+            return Geometry_Category.ABSTRACT_GEOMETRY;
+        case 101:
+        case "ZONE":
+            return Geometry_Category.ZONE;
+        case 102:
+        case "TRIGGER":
+            return Geometry_Category.TRIGGER;
+        case 103:
+        case "EDGE":
+            return Geometry_Category.EDGE;
+        case 104:
+        case "PATH":
+            return Geometry_Category.PATH;
+        case 105:
+        case "PLANNED_PATH":
+            return Geometry_Category.PLANNED_PATH;
+        case 106:
+        case "HISTORIC_PATH":
+            return Geometry_Category.HISTORIC_PATH;
+        case 151:
+        case "SENSOR_COVERAGE":
+            return Geometry_Category.SENSOR_COVERAGE;
+        case 152:
+        case "SENSOR_HIT":
+            return Geometry_Category.SENSOR_HIT;
+        case 200:
+        case "DEBUG_GEOMETRY":
+            return Geometry_Category.DEBUG_GEOMETRY;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return Geometry_Category.UNRECOGNIZED;
+    }
+}
+export function geometry_CategoryToJSON(object) {
+    switch (object) {
+        case Geometry_Category.UNKNOWN_GEOMETRY:
+            return "UNKNOWN_GEOMETRY";
+        case Geometry_Category.PHYSICAL_GEOMETRY:
+            return "PHYSICAL_GEOMETRY";
+        case Geometry_Category.GROUND:
+            return "GROUND";
+        case Geometry_Category.VEGETATION:
+            return "VEGETATION";
+        case Geometry_Category.STRUCTURE:
+            return "STRUCTURE";
+        case Geometry_Category.ROAD:
+            return "ROAD";
+        case Geometry_Category.ABSTRACT_GEOMETRY:
+            return "ABSTRACT_GEOMETRY";
+        case Geometry_Category.ZONE:
+            return "ZONE";
+        case Geometry_Category.TRIGGER:
+            return "TRIGGER";
+        case Geometry_Category.EDGE:
+            return "EDGE";
+        case Geometry_Category.PATH:
+            return "PATH";
+        case Geometry_Category.PLANNED_PATH:
+            return "PLANNED_PATH";
+        case Geometry_Category.HISTORIC_PATH:
+            return "HISTORIC_PATH";
+        case Geometry_Category.SENSOR_COVERAGE:
+            return "SENSOR_COVERAGE";
+        case Geometry_Category.SENSOR_HIT:
+            return "SENSOR_HIT";
+        case Geometry_Category.DEBUG_GEOMETRY:
+            return "DEBUG_GEOMETRY";
+        case Geometry_Category.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+function createBaseGeometry() {
+    return {
+        id: "",
+        ownerClientId: "",
+        point: undefined,
+        point3d: undefined,
+        line: undefined,
+        line3d: undefined,
+        polygon: undefined,
+        mesh: undefined,
+        spline: undefined,
+        spline3d: undefined,
+        color: undefined,
+        transparency: 0,
+        title: "",
+        labelColor: undefined,
+        labelTransparency: 0,
+        scalable: false,
+        wireframe: false,
+        lineWidth: 0,
+        usage: 0,
+        type: "",
+        category: 0,
+        disabled: false,
+        deleted: false,
+    };
+}
+export const Geometry = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.id !== "") {
+            writer.uint32(10).string(message.id);
+        }
+        if (message.ownerClientId !== "") {
+            writer.uint32(18).string(message.ownerClientId);
+        }
+        if (message.point !== undefined) {
+            Geometry_Point2D.encode(message.point, writer.uint32(26).fork()).ldelim();
+        }
+        if (message.point3d !== undefined) {
+            Geometry_Point3D.encode(message.point3d, writer.uint32(34).fork()).ldelim();
+        }
+        if (message.line !== undefined) {
+            Geometry_Line2D.encode(message.line, writer.uint32(42).fork()).ldelim();
+        }
+        if (message.line3d !== undefined) {
+            Geometry_Line3D.encode(message.line3d, writer.uint32(50).fork()).ldelim();
+        }
+        if (message.polygon !== undefined) {
+            Geometry_Polygon.encode(message.polygon, writer.uint32(58).fork()).ldelim();
+        }
+        if (message.mesh !== undefined) {
+            Geometry_Mesh.encode(message.mesh, writer.uint32(66).fork()).ldelim();
+        }
+        if (message.spline !== undefined) {
+            Geometry_Spline2D.encode(message.spline, writer.uint32(74).fork()).ldelim();
+        }
+        if (message.spline3d !== undefined) {
+            Geometry_Spline3D.encode(message.spline3d, writer.uint32(82).fork()).ldelim();
+        }
+        if (message.color !== undefined) {
+            Color.encode(message.color, writer.uint32(162).fork()).ldelim();
+        }
+        if (message.transparency !== 0) {
+            writer.uint32(173).float(message.transparency);
+        }
+        if (message.title !== "") {
+            writer.uint32(178).string(message.title);
+        }
+        if (message.labelColor !== undefined) {
+            Color.encode(message.labelColor, writer.uint32(186).fork()).ldelim();
+        }
+        if (message.labelTransparency !== 0) {
+            writer.uint32(197).float(message.labelTransparency);
+        }
+        if (message.scalable !== false) {
+            writer.uint32(200).bool(message.scalable);
+        }
+        if (message.wireframe !== false) {
+            writer.uint32(208).bool(message.wireframe);
+        }
+        if (message.lineWidth !== 0) {
+            writer.uint32(221).float(message.lineWidth);
+        }
+        if (message.usage !== 0) {
+            writer.uint32(240).int32(message.usage);
+        }
+        if (message.type !== "") {
+            writer.uint32(250).string(message.type);
+        }
+        if (message.category !== 0) {
+            writer.uint32(256).int32(message.category);
+        }
+        if (message.disabled !== false) {
+            writer.uint32(272).bool(message.disabled);
+        }
+        if (message.deleted !== false) {
+            writer.uint32(280).bool(message.deleted);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseGeometry();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.id = reader.string();
+                    continue;
+                case 2:
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.ownerClientId = reader.string();
+                    continue;
+                case 3:
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.point = Geometry_Point2D.decode(reader, reader.uint32());
+                    continue;
+                case 4:
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.point3d = Geometry_Point3D.decode(reader, reader.uint32());
+                    continue;
+                case 5:
+                    if (tag !== 42) {
+                        break;
+                    }
+                    message.line = Geometry_Line2D.decode(reader, reader.uint32());
+                    continue;
+                case 6:
+                    if (tag !== 50) {
+                        break;
+                    }
+                    message.line3d = Geometry_Line3D.decode(reader, reader.uint32());
+                    continue;
+                case 7:
+                    if (tag !== 58) {
+                        break;
+                    }
+                    message.polygon = Geometry_Polygon.decode(reader, reader.uint32());
+                    continue;
+                case 8:
+                    if (tag !== 66) {
+                        break;
+                    }
+                    message.mesh = Geometry_Mesh.decode(reader, reader.uint32());
+                    continue;
+                case 9:
+                    if (tag !== 74) {
+                        break;
+                    }
+                    message.spline = Geometry_Spline2D.decode(reader, reader.uint32());
+                    continue;
+                case 10:
+                    if (tag !== 82) {
+                        break;
+                    }
+                    message.spline3d = Geometry_Spline3D.decode(reader, reader.uint32());
+                    continue;
+                case 20:
+                    if (tag !== 162) {
+                        break;
+                    }
+                    message.color = Color.decode(reader, reader.uint32());
+                    continue;
+                case 21:
+                    if (tag !== 173) {
+                        break;
+                    }
+                    message.transparency = reader.float();
+                    continue;
+                case 22:
+                    if (tag !== 178) {
+                        break;
+                    }
+                    message.title = reader.string();
+                    continue;
+                case 23:
+                    if (tag !== 186) {
+                        break;
+                    }
+                    message.labelColor = Color.decode(reader, reader.uint32());
+                    continue;
+                case 24:
+                    if (tag !== 197) {
+                        break;
+                    }
+                    message.labelTransparency = reader.float();
+                    continue;
+                case 25:
+                    if (tag !== 200) {
+                        break;
+                    }
+                    message.scalable = reader.bool();
+                    continue;
+                case 26:
+                    if (tag !== 208) {
+                        break;
+                    }
+                    message.wireframe = reader.bool();
+                    continue;
+                case 27:
+                    if (tag !== 221) {
+                        break;
+                    }
+                    message.lineWidth = reader.float();
+                    continue;
+                case 30:
+                    if (tag !== 240) {
+                        break;
+                    }
+                    message.usage = reader.int32();
+                    continue;
+                case 31:
+                    if (tag !== 250) {
+                        break;
+                    }
+                    message.type = reader.string();
+                    continue;
+                case 32:
+                    if (tag !== 256) {
+                        break;
+                    }
+                    message.category = reader.int32();
+                    continue;
+                case 34:
+                    if (tag !== 272) {
+                        break;
+                    }
+                    message.disabled = reader.bool();
+                    continue;
+                case 35:
+                    if (tag !== 280) {
+                        break;
+                    }
+                    message.deleted = reader.bool();
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            id: isSet(object.id) ? globalThis.String(object.id) : "",
+            ownerClientId: isSet(object.ownerClientId) ? globalThis.String(object.ownerClientId) : "",
+            point: isSet(object.point) ? Geometry_Point2D.fromJSON(object.point) : undefined,
+            point3d: isSet(object.point3d) ? Geometry_Point3D.fromJSON(object.point3d) : undefined,
+            line: isSet(object.line) ? Geometry_Line2D.fromJSON(object.line) : undefined,
+            line3d: isSet(object.line3d) ? Geometry_Line3D.fromJSON(object.line3d) : undefined,
+            polygon: isSet(object.polygon) ? Geometry_Polygon.fromJSON(object.polygon) : undefined,
+            mesh: isSet(object.mesh) ? Geometry_Mesh.fromJSON(object.mesh) : undefined,
+            spline: isSet(object.spline) ? Geometry_Spline2D.fromJSON(object.spline) : undefined,
+            spline3d: isSet(object.spline3d) ? Geometry_Spline3D.fromJSON(object.spline3d) : undefined,
+            color: isSet(object.color) ? Color.fromJSON(object.color) : undefined,
+            transparency: isSet(object.transparency) ? globalThis.Number(object.transparency) : 0,
+            title: isSet(object.title) ? globalThis.String(object.title) : "",
+            labelColor: isSet(object.labelColor) ? Color.fromJSON(object.labelColor) : undefined,
+            labelTransparency: isSet(object.labelTransparency) ? globalThis.Number(object.labelTransparency) : 0,
+            scalable: isSet(object.scalable) ? globalThis.Boolean(object.scalable) : false,
+            wireframe: isSet(object.wireframe) ? globalThis.Boolean(object.wireframe) : false,
+            lineWidth: isSet(object.lineWidth) ? globalThis.Number(object.lineWidth) : 0,
+            usage: isSet(object.usage) ? geometry_UsageFromJSON(object.usage) : 0,
+            type: isSet(object.type) ? globalThis.String(object.type) : "",
+            category: isSet(object.category) ? geometry_CategoryFromJSON(object.category) : 0,
+            disabled: isSet(object.disabled) ? globalThis.Boolean(object.disabled) : false,
+            deleted: isSet(object.deleted) ? globalThis.Boolean(object.deleted) : false,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.id !== "") {
+            obj.id = message.id;
+        }
+        if (message.ownerClientId !== "") {
+            obj.ownerClientId = message.ownerClientId;
+        }
+        if (message.point !== undefined) {
+            obj.point = Geometry_Point2D.toJSON(message.point);
+        }
+        if (message.point3d !== undefined) {
+            obj.point3d = Geometry_Point3D.toJSON(message.point3d);
+        }
+        if (message.line !== undefined) {
+            obj.line = Geometry_Line2D.toJSON(message.line);
+        }
+        if (message.line3d !== undefined) {
+            obj.line3d = Geometry_Line3D.toJSON(message.line3d);
+        }
+        if (message.polygon !== undefined) {
+            obj.polygon = Geometry_Polygon.toJSON(message.polygon);
+        }
+        if (message.mesh !== undefined) {
+            obj.mesh = Geometry_Mesh.toJSON(message.mesh);
+        }
+        if (message.spline !== undefined) {
+            obj.spline = Geometry_Spline2D.toJSON(message.spline);
+        }
+        if (message.spline3d !== undefined) {
+            obj.spline3d = Geometry_Spline3D.toJSON(message.spline3d);
+        }
+        if (message.color !== undefined) {
+            obj.color = Color.toJSON(message.color);
+        }
+        if (message.transparency !== 0) {
+            obj.transparency = message.transparency;
+        }
+        if (message.title !== "") {
+            obj.title = message.title;
+        }
+        if (message.labelColor !== undefined) {
+            obj.labelColor = Color.toJSON(message.labelColor);
+        }
+        if (message.labelTransparency !== 0) {
+            obj.labelTransparency = message.labelTransparency;
+        }
+        if (message.scalable !== false) {
+            obj.scalable = message.scalable;
+        }
+        if (message.wireframe !== false) {
+            obj.wireframe = message.wireframe;
+        }
+        if (message.lineWidth !== 0) {
+            obj.lineWidth = message.lineWidth;
+        }
+        if (message.usage !== 0) {
+            obj.usage = geometry_UsageToJSON(message.usage);
+        }
+        if (message.type !== "") {
+            obj.type = message.type;
+        }
+        if (message.category !== 0) {
+            obj.category = geometry_CategoryToJSON(message.category);
+        }
+        if (message.disabled !== false) {
+            obj.disabled = message.disabled;
+        }
+        if (message.deleted !== false) {
+            obj.deleted = message.deleted;
+        }
+        return obj;
+    },
+    create(base) {
+        return Geometry.fromPartial(base !== null && base !== void 0 ? base : {});
+    },
+    fromPartial(object) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
+        const message = createBaseGeometry();
+        message.id = (_a = object.id) !== null && _a !== void 0 ? _a : "";
+        message.ownerClientId = (_b = object.ownerClientId) !== null && _b !== void 0 ? _b : "";
+        message.point = (object.point !== undefined && object.point !== null)
+            ? Geometry_Point2D.fromPartial(object.point)
+            : undefined;
+        message.point3d = (object.point3d !== undefined && object.point3d !== null)
+            ? Geometry_Point3D.fromPartial(object.point3d)
+            : undefined;
+        message.line = (object.line !== undefined && object.line !== null)
+            ? Geometry_Line2D.fromPartial(object.line)
+            : undefined;
+        message.line3d = (object.line3d !== undefined && object.line3d !== null)
+            ? Geometry_Line3D.fromPartial(object.line3d)
+            : undefined;
+        message.polygon = (object.polygon !== undefined && object.polygon !== null)
+            ? Geometry_Polygon.fromPartial(object.polygon)
+            : undefined;
+        message.mesh = (object.mesh !== undefined && object.mesh !== null)
+            ? Geometry_Mesh.fromPartial(object.mesh)
+            : undefined;
+        message.spline = (object.spline !== undefined && object.spline !== null)
+            ? Geometry_Spline2D.fromPartial(object.spline)
+            : undefined;
+        message.spline3d = (object.spline3d !== undefined && object.spline3d !== null)
+            ? Geometry_Spline3D.fromPartial(object.spline3d)
+            : undefined;
+        message.color = (object.color !== undefined && object.color !== null) ? Color.fromPartial(object.color) : undefined;
+        message.transparency = (_c = object.transparency) !== null && _c !== void 0 ? _c : 0;
+        message.title = (_d = object.title) !== null && _d !== void 0 ? _d : "";
+        message.labelColor = (object.labelColor !== undefined && object.labelColor !== null)
+            ? Color.fromPartial(object.labelColor)
+            : undefined;
+        message.labelTransparency = (_e = object.labelTransparency) !== null && _e !== void 0 ? _e : 0;
+        message.scalable = (_f = object.scalable) !== null && _f !== void 0 ? _f : false;
+        message.wireframe = (_g = object.wireframe) !== null && _g !== void 0 ? _g : false;
+        message.lineWidth = (_h = object.lineWidth) !== null && _h !== void 0 ? _h : 0;
+        message.usage = (_j = object.usage) !== null && _j !== void 0 ? _j : 0;
+        message.type = (_k = object.type) !== null && _k !== void 0 ? _k : "";
+        message.category = (_l = object.category) !== null && _l !== void 0 ? _l : 0;
+        message.disabled = (_m = object.disabled) !== null && _m !== void 0 ? _m : false;
+        message.deleted = (_o = object.deleted) !== null && _o !== void 0 ? _o : false;
+        return message;
+    },
+};
+function createBaseGeometry_Point2D() {
+    return { local: undefined, geodetic: undefined };
+}
+export const Geometry_Point2D = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.local !== undefined) {
+            Geometry_LocalPoint2D.encode(message.local, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.geodetic !== undefined) {
+            Geometry_GeodeticPoint2D.encode(message.geodetic, writer.uint32(18).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseGeometry_Point2D();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.local = Geometry_LocalPoint2D.decode(reader, reader.uint32());
+                    continue;
+                case 2:
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.geodetic = Geometry_GeodeticPoint2D.decode(reader, reader.uint32());
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            local: isSet(object.local) ? Geometry_LocalPoint2D.fromJSON(object.local) : undefined,
+            geodetic: isSet(object.geodetic) ? Geometry_GeodeticPoint2D.fromJSON(object.geodetic) : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.local !== undefined) {
+            obj.local = Geometry_LocalPoint2D.toJSON(message.local);
+        }
+        if (message.geodetic !== undefined) {
+            obj.geodetic = Geometry_GeodeticPoint2D.toJSON(message.geodetic);
+        }
+        return obj;
+    },
+    create(base) {
+        return Geometry_Point2D.fromPartial(base !== null && base !== void 0 ? base : {});
+    },
+    fromPartial(object) {
+        const message = createBaseGeometry_Point2D();
+        message.local = (object.local !== undefined && object.local !== null)
+            ? Geometry_LocalPoint2D.fromPartial(object.local)
+            : undefined;
+        message.geodetic = (object.geodetic !== undefined && object.geodetic !== null)
+            ? Geometry_GeodeticPoint2D.fromPartial(object.geodetic)
+            : undefined;
+        return message;
+    },
+};
+function createBaseGeometry_LocalPoint2D() {
+    return { x: 0, y: 0 };
+}
+export const Geometry_LocalPoint2D = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.x !== 0) {
+            writer.uint32(13).float(message.x);
+        }
+        if (message.y !== 0) {
+            writer.uint32(21).float(message.y);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseGeometry_LocalPoint2D();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 13) {
+                        break;
+                    }
+                    message.x = reader.float();
+                    continue;
+                case 2:
+                    if (tag !== 21) {
+                        break;
+                    }
+                    message.y = reader.float();
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            x: isSet(object.x) ? globalThis.Number(object.x) : 0,
+            y: isSet(object.y) ? globalThis.Number(object.y) : 0,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.x !== 0) {
+            obj.x = message.x;
+        }
+        if (message.y !== 0) {
+            obj.y = message.y;
+        }
+        return obj;
+    },
+    create(base) {
+        return Geometry_LocalPoint2D.fromPartial(base !== null && base !== void 0 ? base : {});
+    },
+    fromPartial(object) {
+        var _a, _b;
+        const message = createBaseGeometry_LocalPoint2D();
+        message.x = (_a = object.x) !== null && _a !== void 0 ? _a : 0;
+        message.y = (_b = object.y) !== null && _b !== void 0 ? _b : 0;
+        return message;
+    },
+};
+function createBaseGeometry_GeodeticPoint2D() {
+    return { longitude: 0, latitude: 0 };
+}
+export const Geometry_GeodeticPoint2D = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.longitude !== 0) {
+            writer.uint32(9).double(message.longitude);
+        }
+        if (message.latitude !== 0) {
+            writer.uint32(17).double(message.latitude);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseGeometry_GeodeticPoint2D();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 9) {
+                        break;
+                    }
+                    message.longitude = reader.double();
+                    continue;
+                case 2:
+                    if (tag !== 17) {
+                        break;
+                    }
+                    message.latitude = reader.double();
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            longitude: isSet(object.longitude) ? globalThis.Number(object.longitude) : 0,
+            latitude: isSet(object.latitude) ? globalThis.Number(object.latitude) : 0,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.longitude !== 0) {
+            obj.longitude = message.longitude;
+        }
+        if (message.latitude !== 0) {
+            obj.latitude = message.latitude;
+        }
+        return obj;
+    },
+    create(base) {
+        return Geometry_GeodeticPoint2D.fromPartial(base !== null && base !== void 0 ? base : {});
+    },
+    fromPartial(object) {
+        var _a, _b;
+        const message = createBaseGeometry_GeodeticPoint2D();
+        message.longitude = (_a = object.longitude) !== null && _a !== void 0 ? _a : 0;
+        message.latitude = (_b = object.latitude) !== null && _b !== void 0 ? _b : 0;
+        return message;
+    },
+};
+function createBaseGeometry_Point3D() {
+    return { local: undefined, geodetic: undefined };
+}
+export const Geometry_Point3D = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.local !== undefined) {
+            Geometry_LocalPoint3D.encode(message.local, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.geodetic !== undefined) {
+            Geometry_GeodeticPoint3D.encode(message.geodetic, writer.uint32(18).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseGeometry_Point3D();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.local = Geometry_LocalPoint3D.decode(reader, reader.uint32());
+                    continue;
+                case 2:
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.geodetic = Geometry_GeodeticPoint3D.decode(reader, reader.uint32());
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            local: isSet(object.local) ? Geometry_LocalPoint3D.fromJSON(object.local) : undefined,
+            geodetic: isSet(object.geodetic) ? Geometry_GeodeticPoint3D.fromJSON(object.geodetic) : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.local !== undefined) {
+            obj.local = Geometry_LocalPoint3D.toJSON(message.local);
+        }
+        if (message.geodetic !== undefined) {
+            obj.geodetic = Geometry_GeodeticPoint3D.toJSON(message.geodetic);
+        }
+        return obj;
+    },
+    create(base) {
+        return Geometry_Point3D.fromPartial(base !== null && base !== void 0 ? base : {});
+    },
+    fromPartial(object) {
+        const message = createBaseGeometry_Point3D();
+        message.local = (object.local !== undefined && object.local !== null)
+            ? Geometry_LocalPoint3D.fromPartial(object.local)
+            : undefined;
+        message.geodetic = (object.geodetic !== undefined && object.geodetic !== null)
+            ? Geometry_GeodeticPoint3D.fromPartial(object.geodetic)
+            : undefined;
+        return message;
+    },
+};
+function createBaseGeometry_LocalPoint3D() {
+    return { x: 0, y: 0, z: 0 };
+}
+export const Geometry_LocalPoint3D = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.x !== 0) {
+            writer.uint32(13).float(message.x);
+        }
+        if (message.y !== 0) {
+            writer.uint32(21).float(message.y);
+        }
+        if (message.z !== 0) {
+            writer.uint32(29).float(message.z);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseGeometry_LocalPoint3D();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 13) {
+                        break;
+                    }
+                    message.x = reader.float();
+                    continue;
+                case 2:
+                    if (tag !== 21) {
+                        break;
+                    }
+                    message.y = reader.float();
+                    continue;
+                case 3:
+                    if (tag !== 29) {
+                        break;
+                    }
+                    message.z = reader.float();
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            x: isSet(object.x) ? globalThis.Number(object.x) : 0,
+            y: isSet(object.y) ? globalThis.Number(object.y) : 0,
+            z: isSet(object.z) ? globalThis.Number(object.z) : 0,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.x !== 0) {
+            obj.x = message.x;
+        }
+        if (message.y !== 0) {
+            obj.y = message.y;
+        }
+        if (message.z !== 0) {
+            obj.z = message.z;
+        }
+        return obj;
+    },
+    create(base) {
+        return Geometry_LocalPoint3D.fromPartial(base !== null && base !== void 0 ? base : {});
+    },
+    fromPartial(object) {
+        var _a, _b, _c;
+        const message = createBaseGeometry_LocalPoint3D();
+        message.x = (_a = object.x) !== null && _a !== void 0 ? _a : 0;
+        message.y = (_b = object.y) !== null && _b !== void 0 ? _b : 0;
+        message.z = (_c = object.z) !== null && _c !== void 0 ? _c : 0;
+        return message;
+    },
+};
+function createBaseGeometry_GeodeticPoint3D() {
+    return { longitude: 0, latitude: 0, altitude: 0 };
+}
+export const Geometry_GeodeticPoint3D = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.longitude !== 0) {
+            writer.uint32(9).double(message.longitude);
+        }
+        if (message.latitude !== 0) {
+            writer.uint32(17).double(message.latitude);
+        }
+        if (message.altitude !== 0) {
+            writer.uint32(25).double(message.altitude);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseGeometry_GeodeticPoint3D();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 9) {
+                        break;
+                    }
+                    message.longitude = reader.double();
+                    continue;
+                case 2:
+                    if (tag !== 17) {
+                        break;
+                    }
+                    message.latitude = reader.double();
+                    continue;
+                case 3:
+                    if (tag !== 25) {
+                        break;
+                    }
+                    message.altitude = reader.double();
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            longitude: isSet(object.longitude) ? globalThis.Number(object.longitude) : 0,
+            latitude: isSet(object.latitude) ? globalThis.Number(object.latitude) : 0,
+            altitude: isSet(object.altitude) ? globalThis.Number(object.altitude) : 0,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.longitude !== 0) {
+            obj.longitude = message.longitude;
+        }
+        if (message.latitude !== 0) {
+            obj.latitude = message.latitude;
+        }
+        if (message.altitude !== 0) {
+            obj.altitude = message.altitude;
+        }
+        return obj;
+    },
+    create(base) {
+        return Geometry_GeodeticPoint3D.fromPartial(base !== null && base !== void 0 ? base : {});
+    },
+    fromPartial(object) {
+        var _a, _b, _c;
+        const message = createBaseGeometry_GeodeticPoint3D();
+        message.longitude = (_a = object.longitude) !== null && _a !== void 0 ? _a : 0;
+        message.latitude = (_b = object.latitude) !== null && _b !== void 0 ? _b : 0;
+        message.altitude = (_c = object.altitude) !== null && _c !== void 0 ? _c : 0;
+        return message;
+    },
+};
+function createBaseGeometry_Line2D() {
+    return { points: [] };
+}
+export const Geometry_Line2D = {
+    encode(message, writer = _m0.Writer.create()) {
+        for (const v of message.points) {
+            Geometry_Point2D.encode(v, writer.uint32(10).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseGeometry_Line2D();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.points.push(Geometry_Point2D.decode(reader, reader.uint32()));
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            points: globalThis.Array.isArray(object === null || object === void 0 ? void 0 : object.points)
+                ? object.points.map((e) => Geometry_Point2D.fromJSON(e))
+                : [],
+        };
+    },
+    toJSON(message) {
+        var _a;
+        const obj = {};
+        if ((_a = message.points) === null || _a === void 0 ? void 0 : _a.length) {
+            obj.points = message.points.map((e) => Geometry_Point2D.toJSON(e));
+        }
+        return obj;
+    },
+    create(base) {
+        return Geometry_Line2D.fromPartial(base !== null && base !== void 0 ? base : {});
+    },
+    fromPartial(object) {
+        var _a;
+        const message = createBaseGeometry_Line2D();
+        message.points = ((_a = object.points) === null || _a === void 0 ? void 0 : _a.map((e) => Geometry_Point2D.fromPartial(e))) || [];
+        return message;
+    },
+};
+function createBaseGeometry_Line3D() {
+    return { points: [] };
+}
+export const Geometry_Line3D = {
+    encode(message, writer = _m0.Writer.create()) {
+        for (const v of message.points) {
+            Geometry_Point3D.encode(v, writer.uint32(10).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseGeometry_Line3D();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.points.push(Geometry_Point3D.decode(reader, reader.uint32()));
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            points: globalThis.Array.isArray(object === null || object === void 0 ? void 0 : object.points)
+                ? object.points.map((e) => Geometry_Point3D.fromJSON(e))
+                : [],
+        };
+    },
+    toJSON(message) {
+        var _a;
+        const obj = {};
+        if ((_a = message.points) === null || _a === void 0 ? void 0 : _a.length) {
+            obj.points = message.points.map((e) => Geometry_Point3D.toJSON(e));
+        }
+        return obj;
+    },
+    create(base) {
+        return Geometry_Line3D.fromPartial(base !== null && base !== void 0 ? base : {});
+    },
+    fromPartial(object) {
+        var _a;
+        const message = createBaseGeometry_Line3D();
+        message.points = ((_a = object.points) === null || _a === void 0 ? void 0 : _a.map((e) => Geometry_Point3D.fromPartial(e))) || [];
+        return message;
+    },
+};
+function createBaseGeometry_Polygon() {
+    return { points: [], base: 0, height: 0 };
+}
+export const Geometry_Polygon = {
+    encode(message, writer = _m0.Writer.create()) {
+        for (const v of message.points) {
+            Geometry_Point2D.encode(v, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.base !== 0) {
+            writer.uint32(21).float(message.base);
+        }
+        if (message.height !== 0) {
+            writer.uint32(29).float(message.height);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseGeometry_Polygon();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.points.push(Geometry_Point2D.decode(reader, reader.uint32()));
+                    continue;
+                case 2:
+                    if (tag !== 21) {
+                        break;
+                    }
+                    message.base = reader.float();
+                    continue;
+                case 3:
+                    if (tag !== 29) {
+                        break;
+                    }
+                    message.height = reader.float();
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            points: globalThis.Array.isArray(object === null || object === void 0 ? void 0 : object.points)
+                ? object.points.map((e) => Geometry_Point2D.fromJSON(e))
+                : [],
+            base: isSet(object.base) ? globalThis.Number(object.base) : 0,
+            height: isSet(object.height) ? globalThis.Number(object.height) : 0,
+        };
+    },
+    toJSON(message) {
+        var _a;
+        const obj = {};
+        if ((_a = message.points) === null || _a === void 0 ? void 0 : _a.length) {
+            obj.points = message.points.map((e) => Geometry_Point2D.toJSON(e));
+        }
+        if (message.base !== 0) {
+            obj.base = message.base;
+        }
+        if (message.height !== 0) {
+            obj.height = message.height;
+        }
+        return obj;
+    },
+    create(base) {
+        return Geometry_Polygon.fromPartial(base !== null && base !== void 0 ? base : {});
+    },
+    fromPartial(object) {
+        var _a, _b, _c;
+        const message = createBaseGeometry_Polygon();
+        message.points = ((_a = object.points) === null || _a === void 0 ? void 0 : _a.map((e) => Geometry_Point2D.fromPartial(e))) || [];
+        message.base = (_b = object.base) !== null && _b !== void 0 ? _b : 0;
+        message.height = (_c = object.height) !== null && _c !== void 0 ? _c : 0;
+        return message;
+    },
+};
+function createBaseGeometry_Mesh() {
+    return { vertices: [], indices: [], normals: [] };
+}
+export const Geometry_Mesh = {
+    encode(message, writer = _m0.Writer.create()) {
+        for (const v of message.vertices) {
+            Geometry_LocalPoint3D.encode(v, writer.uint32(10).fork()).ldelim();
+        }
+        writer.uint32(18).fork();
+        for (const v of message.indices) {
+            writer.int32(v);
+        }
+        writer.ldelim();
+        for (const v of message.normals) {
+            Geometry_LocalPoint3D.encode(v, writer.uint32(26).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseGeometry_Mesh();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.vertices.push(Geometry_LocalPoint3D.decode(reader, reader.uint32()));
+                    continue;
+                case 2:
+                    if (tag === 16) {
+                        message.indices.push(reader.int32());
+                        continue;
+                    }
+                    if (tag === 18) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.indices.push(reader.int32());
+                        }
+                        continue;
+                    }
+                    break;
+                case 3:
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.normals.push(Geometry_LocalPoint3D.decode(reader, reader.uint32()));
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            vertices: globalThis.Array.isArray(object === null || object === void 0 ? void 0 : object.vertices)
+                ? object.vertices.map((e) => Geometry_LocalPoint3D.fromJSON(e))
+                : [],
+            indices: globalThis.Array.isArray(object === null || object === void 0 ? void 0 : object.indices) ? object.indices.map((e) => globalThis.Number(e)) : [],
+            normals: globalThis.Array.isArray(object === null || object === void 0 ? void 0 : object.normals)
+                ? object.normals.map((e) => Geometry_LocalPoint3D.fromJSON(e))
+                : [],
+        };
+    },
+    toJSON(message) {
+        var _a, _b, _c;
+        const obj = {};
+        if ((_a = message.vertices) === null || _a === void 0 ? void 0 : _a.length) {
+            obj.vertices = message.vertices.map((e) => Geometry_LocalPoint3D.toJSON(e));
+        }
+        if ((_b = message.indices) === null || _b === void 0 ? void 0 : _b.length) {
+            obj.indices = message.indices.map((e) => Math.round(e));
+        }
+        if ((_c = message.normals) === null || _c === void 0 ? void 0 : _c.length) {
+            obj.normals = message.normals.map((e) => Geometry_LocalPoint3D.toJSON(e));
+        }
+        return obj;
+    },
+    create(base) {
+        return Geometry_Mesh.fromPartial(base !== null && base !== void 0 ? base : {});
+    },
+    fromPartial(object) {
+        var _a, _b, _c;
+        const message = createBaseGeometry_Mesh();
+        message.vertices = ((_a = object.vertices) === null || _a === void 0 ? void 0 : _a.map((e) => Geometry_LocalPoint3D.fromPartial(e))) || [];
+        message.indices = ((_b = object.indices) === null || _b === void 0 ? void 0 : _b.map((e) => e)) || [];
+        message.normals = ((_c = object.normals) === null || _c === void 0 ? void 0 : _c.map((e) => Geometry_LocalPoint3D.fromPartial(e))) || [];
+        return message;
+    },
+};
+function createBaseGeometry_Spline2D() {
+    return { points: [], controlPoints: [] };
+}
+export const Geometry_Spline2D = {
+    encode(message, writer = _m0.Writer.create()) {
+        for (const v of message.points) {
+            Geometry_Point2D.encode(v, writer.uint32(18).fork()).ldelim();
+        }
+        for (const v of message.controlPoints) {
+            Geometry_Point2D.encode(v, writer.uint32(26).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseGeometry_Spline2D();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 2:
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.points.push(Geometry_Point2D.decode(reader, reader.uint32()));
+                    continue;
+                case 3:
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.controlPoints.push(Geometry_Point2D.decode(reader, reader.uint32()));
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            points: globalThis.Array.isArray(object === null || object === void 0 ? void 0 : object.points)
+                ? object.points.map((e) => Geometry_Point2D.fromJSON(e))
+                : [],
+            controlPoints: globalThis.Array.isArray(object === null || object === void 0 ? void 0 : object.controlPoints)
+                ? object.controlPoints.map((e) => Geometry_Point2D.fromJSON(e))
+                : [],
+        };
+    },
+    toJSON(message) {
+        var _a, _b;
+        const obj = {};
+        if ((_a = message.points) === null || _a === void 0 ? void 0 : _a.length) {
+            obj.points = message.points.map((e) => Geometry_Point2D.toJSON(e));
+        }
+        if ((_b = message.controlPoints) === null || _b === void 0 ? void 0 : _b.length) {
+            obj.controlPoints = message.controlPoints.map((e) => Geometry_Point2D.toJSON(e));
+        }
+        return obj;
+    },
+    create(base) {
+        return Geometry_Spline2D.fromPartial(base !== null && base !== void 0 ? base : {});
+    },
+    fromPartial(object) {
+        var _a, _b;
+        const message = createBaseGeometry_Spline2D();
+        message.points = ((_a = object.points) === null || _a === void 0 ? void 0 : _a.map((e) => Geometry_Point2D.fromPartial(e))) || [];
+        message.controlPoints = ((_b = object.controlPoints) === null || _b === void 0 ? void 0 : _b.map((e) => Geometry_Point2D.fromPartial(e))) || [];
+        return message;
+    },
+};
+function createBaseGeometry_Spline3D() {
+    return { points: [], controlPoints: [] };
+}
+export const Geometry_Spline3D = {
+    encode(message, writer = _m0.Writer.create()) {
+        for (const v of message.points) {
+            Geometry_Point3D.encode(v, writer.uint32(18).fork()).ldelim();
+        }
+        for (const v of message.controlPoints) {
+            Geometry_Point3D.encode(v, writer.uint32(26).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseGeometry_Spline3D();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 2:
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.points.push(Geometry_Point3D.decode(reader, reader.uint32()));
+                    continue;
+                case 3:
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.controlPoints.push(Geometry_Point3D.decode(reader, reader.uint32()));
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            points: globalThis.Array.isArray(object === null || object === void 0 ? void 0 : object.points)
+                ? object.points.map((e) => Geometry_Point3D.fromJSON(e))
+                : [],
+            controlPoints: globalThis.Array.isArray(object === null || object === void 0 ? void 0 : object.controlPoints)
+                ? object.controlPoints.map((e) => Geometry_Point3D.fromJSON(e))
+                : [],
+        };
+    },
+    toJSON(message) {
+        var _a, _b;
+        const obj = {};
+        if ((_a = message.points) === null || _a === void 0 ? void 0 : _a.length) {
+            obj.points = message.points.map((e) => Geometry_Point3D.toJSON(e));
+        }
+        if ((_b = message.controlPoints) === null || _b === void 0 ? void 0 : _b.length) {
+            obj.controlPoints = message.controlPoints.map((e) => Geometry_Point3D.toJSON(e));
+        }
+        return obj;
+    },
+    create(base) {
+        return Geometry_Spline3D.fromPartial(base !== null && base !== void 0 ? base : {});
+    },
+    fromPartial(object) {
+        var _a, _b;
+        const message = createBaseGeometry_Spline3D();
+        message.points = ((_a = object.points) === null || _a === void 0 ? void 0 : _a.map((e) => Geometry_Point3D.fromPartial(e))) || [];
+        message.controlPoints = ((_b = object.controlPoints) === null || _b === void 0 ? void 0 : _b.map((e) => Geometry_Point3D.fromPartial(e))) || [];
+        return message;
+    },
+};
+function isSet(value) {
+    return value !== null && value !== undefined;
+}
+//# sourceMappingURL=Geometry.js.map