spot-sdk-ts/dist/bosdyn/api/trajectory.js

TypeScript bindings based on protobufs (proto3) provided by Boston Dynamics

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.ScalarTrajectoryPoint = exports.ScalarTrajectory = exports.WrenchTrajectoryPoint = exports.WrenchTrajectory = exports.Vec3TrajectoryPoint = exports.Vec3Trajectory = exports.SE3TrajectoryPoint = exports.SE3Trajectory = exports.SE2TrajectoryPoint = exports.SE2Trajectory = exports.angularInterpolationToJSON = exports.angularInterpolationFromJSON = exports.AngularInterpolation = exports.positionalInterpolationToJSON = exports.positionalInterpolationFromJSON = exports.PositionalInterpolation = exports.protobufPackage = void 0;
/* eslint-disable */
const timestamp_1 = require("../../google/protobuf/timestamp");
const geometry_1 = require("./geometry");
const duration_1 = require("../../google/protobuf/duration");
const minimal_1 = __importDefault(require("protobufjs/minimal"));
const wrappers_1 = require("../../google/protobuf/wrappers");
exports.protobufPackage = "bosdyn.api";
/** Parameters for how positional trajectories will be interpolated on robot. */
var PositionalInterpolation;
(function (PositionalInterpolation) {
    /** POS_INTERP_UNKNOWN - Unknown interpolation, do not use. */
    PositionalInterpolation[PositionalInterpolation["POS_INTERP_UNKNOWN"] = 0] = "POS_INTERP_UNKNOWN";
    /** POS_INTERP_LINEAR - Linear interpolation for positional data. */
    PositionalInterpolation[PositionalInterpolation["POS_INTERP_LINEAR"] = 1] = "POS_INTERP_LINEAR";
    /** POS_INTERP_CUBIC - Cubic interpolation for positional data. */
    PositionalInterpolation[PositionalInterpolation["POS_INTERP_CUBIC"] = 2] = "POS_INTERP_CUBIC";
    PositionalInterpolation[PositionalInterpolation["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
})(PositionalInterpolation = exports.PositionalInterpolation || (exports.PositionalInterpolation = {}));
function positionalInterpolationFromJSON(object) {
    switch (object) {
        case 0:
        case "POS_INTERP_UNKNOWN":
            return PositionalInterpolation.POS_INTERP_UNKNOWN;
        case 1:
        case "POS_INTERP_LINEAR":
            return PositionalInterpolation.POS_INTERP_LINEAR;
        case 2:
        case "POS_INTERP_CUBIC":
            return PositionalInterpolation.POS_INTERP_CUBIC;
        case -1:
        case "UNRECOGNIZED":
        default:
            return PositionalInterpolation.UNRECOGNIZED;
    }
}
exports.positionalInterpolationFromJSON = positionalInterpolationFromJSON;
function positionalInterpolationToJSON(object) {
    switch (object) {
        case PositionalInterpolation.POS_INTERP_UNKNOWN:
            return "POS_INTERP_UNKNOWN";
        case PositionalInterpolation.POS_INTERP_LINEAR:
            return "POS_INTERP_LINEAR";
        case PositionalInterpolation.POS_INTERP_CUBIC:
            return "POS_INTERP_CUBIC";
        case PositionalInterpolation.UNRECOGNIZED:
        default:
            return "UNRECOGNIZED";
    }
}
exports.positionalInterpolationToJSON = positionalInterpolationToJSON;
/** Parameters for how angular trajectories will be interpolated on robot. */
var AngularInterpolation;
(function (AngularInterpolation) {
    /** ANG_INTERP_UNKNOWN - Unknown interpolation, do not use. */
    AngularInterpolation[AngularInterpolation["ANG_INTERP_UNKNOWN"] = 0] = "ANG_INTERP_UNKNOWN";
    /** ANG_INTERP_LINEAR - Linear interpolation for angular data. */
    AngularInterpolation[AngularInterpolation["ANG_INTERP_LINEAR"] = 1] = "ANG_INTERP_LINEAR";
    /** ANG_INTERP_CUBIC_EULER - Cubic interpolation (using Euler method) for angular data. */
    AngularInterpolation[AngularInterpolation["ANG_INTERP_CUBIC_EULER"] = 2] = "ANG_INTERP_CUBIC_EULER";
    AngularInterpolation[AngularInterpolation["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
})(AngularInterpolation = exports.AngularInterpolation || (exports.AngularInterpolation = {}));
function angularInterpolationFromJSON(object) {
    switch (object) {
        case 0:
        case "ANG_INTERP_UNKNOWN":
            return AngularInterpolation.ANG_INTERP_UNKNOWN;
        case 1:
        case "ANG_INTERP_LINEAR":
            return AngularInterpolation.ANG_INTERP_LINEAR;
        case 2:
        case "ANG_INTERP_CUBIC_EULER":
            return AngularInterpolation.ANG_INTERP_CUBIC_EULER;
        case -1:
        case "UNRECOGNIZED":
        default:
            return AngularInterpolation.UNRECOGNIZED;
    }
}
exports.angularInterpolationFromJSON = angularInterpolationFromJSON;
function angularInterpolationToJSON(object) {
    switch (object) {
        case AngularInterpolation.ANG_INTERP_UNKNOWN:
            return "ANG_INTERP_UNKNOWN";
        case AngularInterpolation.ANG_INTERP_LINEAR:
            return "ANG_INTERP_LINEAR";
        case AngularInterpolation.ANG_INTERP_CUBIC_EULER:
            return "ANG_INTERP_CUBIC_EULER";
        case AngularInterpolation.UNRECOGNIZED:
        default:
            return "UNRECOGNIZED";
    }
}
exports.angularInterpolationToJSON = angularInterpolationToJSON;
function createBaseSE2Trajectory() {
    return { points: [], referenceTime: undefined, interpolation: 0 };
}
exports.SE2Trajectory = {
    encode(message, writer = minimal_1.default.Writer.create()) {
        for (const v of message.points) {
            exports.SE2TrajectoryPoint.encode(v, writer.uint32(10).fork()).ldelim();
        }
        if (message.referenceTime !== undefined) {
            timestamp_1.Timestamp.encode(toTimestamp(message.referenceTime), writer.uint32(26).fork()).ldelim();
        }
        if (message.interpolation !== 0) {
            writer.uint32(32).int32(message.interpolation);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseSE2Trajectory();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.points.push(exports.SE2TrajectoryPoint.decode(reader, reader.uint32()));
                    break;
                case 3:
                    message.referenceTime = fromTimestamp(timestamp_1.Timestamp.decode(reader, reader.uint32()));
                    break;
                case 4:
                    message.interpolation = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            points: Array.isArray(object?.points)
                ? object.points.map((e) => exports.SE2TrajectoryPoint.fromJSON(e))
                : [],
            referenceTime: isSet(object.referenceTime)
                ? fromJsonTimestamp(object.referenceTime)
                : undefined,
            interpolation: isSet(object.interpolation)
                ? positionalInterpolationFromJSON(object.interpolation)
                : 0,
        };
    },
    toJSON(message) {
        const obj = {};
        if (message.points) {
            obj.points = message.points.map((e) => e ? exports.SE2TrajectoryPoint.toJSON(e) : undefined);
        }
        else {
            obj.points = [];
        }
        message.referenceTime !== undefined &&
            (obj.referenceTime = message.referenceTime.toISOString());
        message.interpolation !== undefined &&
            (obj.interpolation = positionalInterpolationToJSON(message.interpolation));
        return obj;
    },
    fromPartial(object) {
        const message = createBaseSE2Trajectory();
        message.points =
            object.points?.map((e) => exports.SE2TrajectoryPoint.fromPartial(e)) || [];
        message.referenceTime = object.referenceTime ?? undefined;
        message.interpolation = object.interpolation ?? 0;
        return message;
    },
};
function createBaseSE2TrajectoryPoint() {
    return { pose: undefined, timeSinceReference: undefined };
}
exports.SE2TrajectoryPoint = {
    encode(message, writer = minimal_1.default.Writer.create()) {
        if (message.pose !== undefined) {
            geometry_1.SE2Pose.encode(message.pose, writer.uint32(10).fork()).ldelim();
        }
        if (message.timeSinceReference !== undefined) {
            duration_1.Duration.encode(message.timeSinceReference, writer.uint32(26).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseSE2TrajectoryPoint();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.pose = geometry_1.SE2Pose.decode(reader, reader.uint32());
                    break;
                case 3:
                    message.timeSinceReference = duration_1.Duration.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            pose: isSet(object.pose) ? geometry_1.SE2Pose.fromJSON(object.pose) : undefined,
            timeSinceReference: isSet(object.timeSinceReference)
                ? duration_1.Duration.fromJSON(object.timeSinceReference)
                : undefined,
        };
    },
    toJSON(message) {
        const obj = {};
        message.pose !== undefined &&
            (obj.pose = message.pose ? geometry_1.SE2Pose.toJSON(message.pose) : undefined);
        message.timeSinceReference !== undefined &&
            (obj.timeSinceReference = message.timeSinceReference
                ? duration_1.Duration.toJSON(message.timeSinceReference)
                : undefined);
        return obj;
    },
    fromPartial(object) {
        const message = createBaseSE2TrajectoryPoint();
        message.pose =
            object.pose !== undefined && object.pose !== null
                ? geometry_1.SE2Pose.fromPartial(object.pose)
                : undefined;
        message.timeSinceReference =
            object.timeSinceReference !== undefined &&
                object.timeSinceReference !== null
                ? duration_1.Duration.fromPartial(object.timeSinceReference)
                : undefined;
        return message;
    },
};
function createBaseSE3Trajectory() {
    return {
        points: [],
        referenceTime: undefined,
        posInterpolation: 0,
        angInterpolation: 0,
    };
}
exports.SE3Trajectory = {
    encode(message, writer = minimal_1.default.Writer.create()) {
        for (const v of message.points) {
            exports.SE3TrajectoryPoint.encode(v, writer.uint32(10).fork()).ldelim();
        }
        if (message.referenceTime !== undefined) {
            timestamp_1.Timestamp.encode(toTimestamp(message.referenceTime), writer.uint32(26).fork()).ldelim();
        }
        if (message.posInterpolation !== 0) {
            writer.uint32(32).int32(message.posInterpolation);
        }
        if (message.angInterpolation !== 0) {
            writer.uint32(40).int32(message.angInterpolation);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseSE3Trajectory();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.points.push(exports.SE3TrajectoryPoint.decode(reader, reader.uint32()));
                    break;
                case 3:
                    message.referenceTime = fromTimestamp(timestamp_1.Timestamp.decode(reader, reader.uint32()));
                    break;
                case 4:
                    message.posInterpolation = reader.int32();
                    break;
                case 5:
                    message.angInterpolation = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            points: Array.isArray(object?.points)
                ? object.points.map((e) => exports.SE3TrajectoryPoint.fromJSON(e))
                : [],
            referenceTime: isSet(object.referenceTime)
                ? fromJsonTimestamp(object.referenceTime)
                : undefined,
            posInterpolation: isSet(object.posInterpolation)
                ? positionalInterpolationFromJSON(object.posInterpolation)
                : 0,
            angInterpolation: isSet(object.angInterpolation)
                ? angularInterpolationFromJSON(object.angInterpolation)
                : 0,
        };
    },
    toJSON(message) {
        const obj = {};
        if (message.points) {
            obj.points = message.points.map((e) => e ? exports.SE3TrajectoryPoint.toJSON(e) : undefined);
        }
        else {
            obj.points = [];
        }
        message.referenceTime !== undefined &&
            (obj.referenceTime = message.referenceTime.toISOString());
        message.posInterpolation !== undefined &&
            (obj.posInterpolation = positionalInterpolationToJSON(message.posInterpolation));
        message.angInterpolation !== undefined &&
            (obj.angInterpolation = angularInterpolationToJSON(message.angInterpolation));
        return obj;
    },
    fromPartial(object) {
        const message = createBaseSE3Trajectory();
        message.points =
            object.points?.map((e) => exports.SE3TrajectoryPoint.fromPartial(e)) || [];
        message.referenceTime = object.referenceTime ?? undefined;
        message.posInterpolation = object.posInterpolation ?? 0;
        message.angInterpolation = object.angInterpolation ?? 0;
        return message;
    },
};
function createBaseSE3TrajectoryPoint() {
    return {
        pose: undefined,
        velocity: undefined,
        timeSinceReference: undefined,
    };
}
exports.SE3TrajectoryPoint = {
    encode(message, writer = minimal_1.default.Writer.create()) {
        if (message.pose !== undefined) {
            geometry_1.SE3Pose.encode(message.pose, writer.uint32(10).fork()).ldelim();
        }
        if (message.velocity !== undefined) {
            geometry_1.SE3Velocity.encode(message.velocity, writer.uint32(18).fork()).ldelim();
        }
        if (message.timeSinceReference !== undefined) {
            duration_1.Duration.encode(message.timeSinceReference, writer.uint32(26).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseSE3TrajectoryPoint();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.pose = geometry_1.SE3Pose.decode(reader, reader.uint32());
                    break;
                case 2:
                    message.velocity = geometry_1.SE3Velocity.decode(reader, reader.uint32());
                    break;
                case 3:
                    message.timeSinceReference = duration_1.Duration.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            pose: isSet(object.pose) ? geometry_1.SE3Pose.fromJSON(object.pose) : undefined,
            velocity: isSet(object.velocity)
                ? geometry_1.SE3Velocity.fromJSON(object.velocity)
                : undefined,
            timeSinceReference: isSet(object.timeSinceReference)
                ? duration_1.Duration.fromJSON(object.timeSinceReference)
                : undefined,
        };
    },
    toJSON(message) {
        const obj = {};
        message.pose !== undefined &&
            (obj.pose = message.pose ? geometry_1.SE3Pose.toJSON(message.pose) : undefined);
        message.velocity !== undefined &&
            (obj.velocity = message.velocity
                ? geometry_1.SE3Velocity.toJSON(message.velocity)
                : undefined);
        message.timeSinceReference !== undefined &&
            (obj.timeSinceReference = message.timeSinceReference
                ? duration_1.Duration.toJSON(message.timeSinceReference)
                : undefined);
        return obj;
    },
    fromPartial(object) {
        const message = createBaseSE3TrajectoryPoint();
        message.pose =
            object.pose !== undefined && object.pose !== null
                ? geometry_1.SE3Pose.fromPartial(object.pose)
                : undefined;
        message.velocity =
            object.velocity !== undefined && object.velocity !== null
                ? geometry_1.SE3Velocity.fromPartial(object.velocity)
                : undefined;
        message.timeSinceReference =
            object.timeSinceReference !== undefined &&
                object.timeSinceReference !== null
                ? duration_1.Duration.fromPartial(object.timeSinceReference)
                : undefined;
        return message;
    },
};
function createBaseVec3Trajectory() {
    return {
        points: [],
        referenceTime: undefined,
        posInterpolation: 0,
        startingVelocity: undefined,
        endingVelocity: undefined,
    };
}
exports.Vec3Trajectory = {
    encode(message, writer = minimal_1.default.Writer.create()) {
        for (const v of message.points) {
            exports.Vec3TrajectoryPoint.encode(v, writer.uint32(10).fork()).ldelim();
        }
        if (message.referenceTime !== undefined) {
            timestamp_1.Timestamp.encode(toTimestamp(message.referenceTime), writer.uint32(26).fork()).ldelim();
        }
        if (message.posInterpolation !== 0) {
            writer.uint32(32).int32(message.posInterpolation);
        }
        if (message.startingVelocity !== undefined) {
            geometry_1.Vec3.encode(message.startingVelocity, writer.uint32(42).fork()).ldelim();
        }
        if (message.endingVelocity !== undefined) {
            geometry_1.Vec3.encode(message.endingVelocity, writer.uint32(50).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseVec3Trajectory();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.points.push(exports.Vec3TrajectoryPoint.decode(reader, reader.uint32()));
                    break;
                case 3:
                    message.referenceTime = fromTimestamp(timestamp_1.Timestamp.decode(reader, reader.uint32()));
                    break;
                case 4:
                    message.posInterpolation = reader.int32();
                    break;
                case 5:
                    message.startingVelocity = geometry_1.Vec3.decode(reader, reader.uint32());
                    break;
                case 6:
                    message.endingVelocity = geometry_1.Vec3.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            points: Array.isArray(object?.points)
                ? object.points.map((e) => exports.Vec3TrajectoryPoint.fromJSON(e))
                : [],
            referenceTime: isSet(object.referenceTime)
                ? fromJsonTimestamp(object.referenceTime)
                : undefined,
            posInterpolation: isSet(object.posInterpolation)
                ? positionalInterpolationFromJSON(object.posInterpolation)
                : 0,
            startingVelocity: isSet(object.startingVelocity)
                ? geometry_1.Vec3.fromJSON(object.startingVelocity)
                : undefined,
            endingVelocity: isSet(object.endingVelocity)
                ? geometry_1.Vec3.fromJSON(object.endingVelocity)
                : undefined,
        };
    },
    toJSON(message) {
        const obj = {};
        if (message.points) {
            obj.points = message.points.map((e) => e ? exports.Vec3TrajectoryPoint.toJSON(e) : undefined);
        }
        else {
            obj.points = [];
        }
        message.referenceTime !== undefined &&
            (obj.referenceTime = message.referenceTime.toISOString());
        message.posInterpolation !== undefined &&
            (obj.posInterpolation = positionalInterpolationToJSON(message.posInterpolation));
        message.startingVelocity !== undefined &&
            (obj.startingVelocity = message.startingVelocity
                ? geometry_1.Vec3.toJSON(message.startingVelocity)
                : undefined);
        message.endingVelocity !== undefined &&
            (obj.endingVelocity = message.endingVelocity
                ? geometry_1.Vec3.toJSON(message.endingVelocity)
                : undefined);
        return obj;
    },
    fromPartial(object) {
        const message = createBaseVec3Trajectory();
        message.points =
            object.points?.map((e) => exports.Vec3TrajectoryPoint.fromPartial(e)) || [];
        message.referenceTime = object.referenceTime ?? undefined;
        message.posInterpolation = object.posInterpolation ?? 0;
        message.startingVelocity =
            object.startingVelocity !== undefined && object.startingVelocity !== null
                ? geometry_1.Vec3.fromPartial(object.startingVelocity)
                : undefined;
        message.endingVelocity =
            object.endingVelocity !== undefined && object.endingVelocity !== null
                ? geometry_1.Vec3.fromPartial(object.endingVelocity)
                : undefined;
        return message;
    },
};
function createBaseVec3TrajectoryPoint() {
    return { point: undefined, linearSpeed: 0, timeSinceReference: undefined };
}
exports.Vec3TrajectoryPoint = {
    encode(message, writer = minimal_1.default.Writer.create()) {
        if (message.point !== undefined) {
            geometry_1.Vec3.encode(message.point, writer.uint32(10).fork()).ldelim();
        }
        if (message.linearSpeed !== 0) {
            writer.uint32(33).double(message.linearSpeed);
        }
        if (message.timeSinceReference !== undefined) {
            duration_1.Duration.encode(message.timeSinceReference, writer.uint32(26).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseVec3TrajectoryPoint();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.point = geometry_1.Vec3.decode(reader, reader.uint32());
                    break;
                case 4:
                    message.linearSpeed = reader.double();
                    break;
                case 3:
                    message.timeSinceReference = duration_1.Duration.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            point: isSet(object.point) ? geometry_1.Vec3.fromJSON(object.point) : undefined,
            linearSpeed: isSet(object.linearSpeed) ? Number(object.linearSpeed) : 0,
            timeSinceReference: isSet(object.timeSinceReference)
                ? duration_1.Duration.fromJSON(object.timeSinceReference)
                : undefined,
        };
    },
    toJSON(message) {
        const obj = {};
        message.point !== undefined &&
            (obj.point = message.point ? geometry_1.Vec3.toJSON(message.point) : undefined);
        message.linearSpeed !== undefined &&
            (obj.linearSpeed = message.linearSpeed);
        message.timeSinceReference !== undefined &&
            (obj.timeSinceReference = message.timeSinceReference
                ? duration_1.Duration.toJSON(message.timeSinceReference)
                : undefined);
        return obj;
    },
    fromPartial(object) {
        const message = createBaseVec3TrajectoryPoint();
        message.point =
            object.point !== undefined && object.point !== null
                ? geometry_1.Vec3.fromPartial(object.point)
                : undefined;
        message.linearSpeed = object.linearSpeed ?? 0;
        message.timeSinceReference =
            object.timeSinceReference !== undefined &&
                object.timeSinceReference !== null
                ? duration_1.Duration.fromPartial(object.timeSinceReference)
                : undefined;
        return message;
    },
};
function createBaseWrenchTrajectory() {
    return { points: [], referenceTime: undefined };
}
exports.WrenchTrajectory = {
    encode(message, writer = minimal_1.default.Writer.create()) {
        for (const v of message.points) {
            exports.WrenchTrajectoryPoint.encode(v, writer.uint32(10).fork()).ldelim();
        }
        if (message.referenceTime !== undefined) {
            timestamp_1.Timestamp.encode(toTimestamp(message.referenceTime), writer.uint32(18).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseWrenchTrajectory();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.points.push(exports.WrenchTrajectoryPoint.decode(reader, reader.uint32()));
                    break;
                case 2:
                    message.referenceTime = fromTimestamp(timestamp_1.Timestamp.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            points: Array.isArray(object?.points)
                ? object.points.map((e) => exports.WrenchTrajectoryPoint.fromJSON(e))
                : [],
            referenceTime: isSet(object.referenceTime)
                ? fromJsonTimestamp(object.referenceTime)
                : undefined,
        };
    },
    toJSON(message) {
        const obj = {};
        if (message.points) {
            obj.points = message.points.map((e) => e ? exports.WrenchTrajectoryPoint.toJSON(e) : undefined);
        }
        else {
            obj.points = [];
        }
        message.referenceTime !== undefined &&
            (obj.referenceTime = message.referenceTime.toISOString());
        return obj;
    },
    fromPartial(object) {
        const message = createBaseWrenchTrajectory();
        message.points =
            object.points?.map((e) => exports.WrenchTrajectoryPoint.fromPartial(e)) || [];
        message.referenceTime = object.referenceTime ?? undefined;
        return message;
    },
};
function createBaseWrenchTrajectoryPoint() {
    return { wrench: undefined, timeSinceReference: undefined };
}
exports.WrenchTrajectoryPoint = {
    encode(message, writer = minimal_1.default.Writer.create()) {
        if (message.wrench !== undefined) {
            geometry_1.Wrench.encode(message.wrench, writer.uint32(10).fork()).ldelim();
        }
        if (message.timeSinceReference !== undefined) {
            duration_1.Duration.encode(message.timeSinceReference, writer.uint32(18).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseWrenchTrajectoryPoint();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.wrench = geometry_1.Wrench.decode(reader, reader.uint32());
                    break;
                case 2:
                    message.timeSinceReference = duration_1.Duration.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            wrench: isSet(object.wrench) ? geometry_1.Wrench.fromJSON(object.wrench) : undefined,
            timeSinceReference: isSet(object.timeSinceReference)
                ? duration_1.Duration.fromJSON(object.timeSinceReference)
                : undefined,
        };
    },
    toJSON(message) {
        const obj = {};
        message.wrench !== undefined &&
            (obj.wrench = message.wrench ? geometry_1.Wrench.toJSON(message.wrench) : undefined);
        message.timeSinceReference !== undefined &&
            (obj.timeSinceReference = message.timeSinceReference
                ? duration_1.Duration.toJSON(message.timeSinceReference)
                : undefined);
        return obj;
    },
    fromPartial(object) {
        const message = createBaseWrenchTrajectoryPoint();
        message.wrench =
            object.wrench !== undefined && object.wrench !== null
                ? geometry_1.Wrench.fromPartial(object.wrench)
                : undefined;
        message.timeSinceReference =
            object.timeSinceReference !== undefined &&
                object.timeSinceReference !== null
                ? duration_1.Duration.fromPartial(object.timeSinceReference)
                : undefined;
        return message;
    },
};
function createBaseScalarTrajectory() {
    return { points: [], referenceTime: undefined, interpolation: 0 };
}
exports.ScalarTrajectory = {
    encode(message, writer = minimal_1.default.Writer.create()) {
        for (const v of message.points) {
            exports.ScalarTrajectoryPoint.encode(v, writer.uint32(10).fork()).ldelim();
        }
        if (message.referenceTime !== undefined) {
            timestamp_1.Timestamp.encode(toTimestamp(message.referenceTime), writer.uint32(18).fork()).ldelim();
        }
        if (message.interpolation !== 0) {
            writer.uint32(24).int32(message.interpolation);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseScalarTrajectory();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.points.push(exports.ScalarTrajectoryPoint.decode(reader, reader.uint32()));
                    break;
                case 2:
                    message.referenceTime = fromTimestamp(timestamp_1.Timestamp.decode(reader, reader.uint32()));
                    break;
                case 3:
                    message.interpolation = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            points: Array.isArray(object?.points)
                ? object.points.map((e) => exports.ScalarTrajectoryPoint.fromJSON(e))
                : [],
            referenceTime: isSet(object.referenceTime)
                ? fromJsonTimestamp(object.referenceTime)
                : undefined,
            interpolation: isSet(object.interpolation)
                ? positionalInterpolationFromJSON(object.interpolation)
                : 0,
        };
    },
    toJSON(message) {
        const obj = {};
        if (message.points) {
            obj.points = message.points.map((e) => e ? exports.ScalarTrajectoryPoint.toJSON(e) : undefined);
        }
        else {
            obj.points = [];
        }
        message.referenceTime !== undefined &&
            (obj.referenceTime = message.referenceTime.toISOString());
        message.interpolation !== undefined &&
            (obj.interpolation = positionalInterpolationToJSON(message.interpolation));
        return obj;
    },
    fromPartial(object) {
        const message = createBaseScalarTrajectory();
        message.points =
            object.points?.map((e) => exports.ScalarTrajectoryPoint.fromPartial(e)) || [];
        message.referenceTime = object.referenceTime ?? undefined;
        message.interpolation = object.interpolation ?? 0;
        return message;
    },
};
function createBaseScalarTrajectoryPoint() {
    return { point: 0, velocity: undefined, timeSinceReference: undefined };
}
exports.ScalarTrajectoryPoint = {
    encode(message, writer = minimal_1.default.Writer.create()) {
        if (message.point !== 0) {
            writer.uint32(9).double(message.point);
        }
        if (message.velocity !== undefined) {
            wrappers_1.DoubleValue.encode({ value: message.velocity }, writer.uint32(18).fork()).ldelim();
        }
        if (message.timeSinceReference !== undefined) {
            duration_1.Duration.encode(message.timeSinceReference, writer.uint32(26).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseScalarTrajectoryPoint();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.point = reader.double();
                    break;
                case 2:
                    message.velocity = wrappers_1.DoubleValue.decode(reader, reader.uint32()).value;
                    break;
                case 3:
                    message.timeSinceReference = duration_1.Duration.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            point: isSet(object.point) ? Number(object.point) : 0,
            velocity: isSet(object.velocity) ? Number(object.velocity) : undefined,
            timeSinceReference: isSet(object.timeSinceReference)
                ? duration_1.Duration.fromJSON(object.timeSinceReference)
                : undefined,
        };
    },
    toJSON(message) {
        const obj = {};
        message.point !== undefined && (obj.point = message.point);
        message.velocity !== undefined && (obj.velocity = message.velocity);
        message.timeSinceReference !== undefined &&
            (obj.timeSinceReference = message.timeSinceReference
                ? duration_1.Duration.toJSON(message.timeSinceReference)
                : undefined);
        return obj;
    },
    fromPartial(object) {
        const message = createBaseScalarTrajectoryPoint();
        message.point = object.point ?? 0;
        message.velocity = object.velocity ?? undefined;
        message.timeSinceReference =
            object.timeSinceReference !== undefined &&
                object.timeSinceReference !== null
                ? duration_1.Duration.fromPartial(object.timeSinceReference)
                : undefined;
        return message;
    },
};
function toTimestamp(date) {
    const seconds = date.getTime() / 1000;
    const nanos = (date.getTime() % 1000) * 1000000;
    return { seconds, nanos };
}
function fromTimestamp(t) {
    let millis = t.seconds * 1000;
    millis += t.nanos / 1000000;
    return new Date(millis);
}
function fromJsonTimestamp(o) {
    if (o instanceof Date) {
        return o;
    }
    else if (typeof o === "string") {
        return new Date(o);
    }
    else {
        return fromTimestamp(timestamp_1.Timestamp.fromJSON(o));
    }
}
function isSet(value) {
    return value !== null && value !== undefined;
}
//# sourceMappingURL=trajectory.js.map