spot-sdk-ts/dist/bosdyn/api/arm_command.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.ArmStopCommand_Feedback = exports.ArmStopCommand_Request = exports.ArmStopCommand = exports.GazeCommand_Feedback = exports.GazeCommand_Request = exports.GazeCommand = exports.ArmJointTrajectory = exports.ArmJointTrajectoryPoint = exports.ArmJointVelocity = exports.ArmJointPosition = exports.ArmJointMoveCommand_Feedback = exports.ArmJointMoveCommand_Request = exports.ArmJointMoveCommand = exports.ArmCartesianCommand_Feedback = exports.ArmCartesianCommand_Request = exports.ArmCartesianCommand = exports.NamedArmPositionsCommand_Feedback = exports.NamedArmPositionsCommand_Request = exports.NamedArmPositionsCommand = exports.ArmVelocityCommand_Feedback = exports.ArmVelocityCommand_Request = exports.ArmVelocityCommand_CartesianVelocity = exports.ArmVelocityCommand_CylindricalVelocity = exports.ArmVelocityCommand = exports.ArmParams = exports.ArmCommand_Feedback = exports.ArmCommand_Request = exports.ArmCommand = exports.gazeCommand_Feedback_StatusToJSON = exports.gazeCommand_Feedback_StatusFromJSON = exports.GazeCommand_Feedback_Status = exports.armJointMoveCommand_Feedback_PlannerStatusToJSON = exports.armJointMoveCommand_Feedback_PlannerStatusFromJSON = exports.ArmJointMoveCommand_Feedback_PlannerStatus = exports.armJointMoveCommand_Feedback_StatusToJSON = exports.armJointMoveCommand_Feedback_StatusFromJSON = exports.ArmJointMoveCommand_Feedback_Status = exports.armCartesianCommand_Feedback_StatusToJSON = exports.armCartesianCommand_Feedback_StatusFromJSON = exports.ArmCartesianCommand_Feedback_Status = exports.armCartesianCommand_Request_AxisModeToJSON = exports.armCartesianCommand_Request_AxisModeFromJSON = exports.ArmCartesianCommand_Request_AxisMode = exports.namedArmPositionsCommand_Feedback_StatusToJSON = exports.namedArmPositionsCommand_Feedback_StatusFromJSON = exports.NamedArmPositionsCommand_Feedback_Status = exports.namedArmPositionsCommand_PositionsToJSON = exports.namedArmPositionsCommand_PositionsFromJSON = exports.NamedArmPositionsCommand_Positions = exports.protobufPackage = void 0;
/* eslint-disable */
const basic_command_1 = require("./basic_command");
const timestamp_1 = require("../../google/protobuf/timestamp");
const geometry_1 = require("./geometry");
const trajectory_1 = require("./trajectory");
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";
var NamedArmPositionsCommand_Positions;
(function (NamedArmPositionsCommand_Positions) {
    /** POSITIONS_UNKNOWN - Invalid request; do not use. */
    NamedArmPositionsCommand_Positions[NamedArmPositionsCommand_Positions["POSITIONS_UNKNOWN"] = 0] = "POSITIONS_UNKNOWN";
    /**
     * POSITIONS_CARRY - The carry position is a damped, force limited position close to stow, with the hand
     * slightly in front of the robot.
     */
    NamedArmPositionsCommand_Positions[NamedArmPositionsCommand_Positions["POSITIONS_CARRY"] = 1] = "POSITIONS_CARRY";
    /**
     * POSITIONS_READY - Move arm to ready position. The ready position is defined with the hand directly in
     * front of and slightly above the body, with the hand facing forward in the robot body +X
     * direction.
     */
    NamedArmPositionsCommand_Positions[NamedArmPositionsCommand_Positions["POSITIONS_READY"] = 2] = "POSITIONS_READY";
    /**
     * POSITIONS_STOW - Stow the arm, safely. If the robot is holding something, it will freeze the arm instead
     * of stowing.  Overriding the carry_state to CARRY_STATE_CARRIABLE_AND_STOWABLE, will allow
     * the robot to stow the arm while grasping an item.
     */
    NamedArmPositionsCommand_Positions[NamedArmPositionsCommand_Positions["POSITIONS_STOW"] = 3] = "POSITIONS_STOW";
    NamedArmPositionsCommand_Positions[NamedArmPositionsCommand_Positions["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
})(NamedArmPositionsCommand_Positions = exports.NamedArmPositionsCommand_Positions || (exports.NamedArmPositionsCommand_Positions = {}));
function namedArmPositionsCommand_PositionsFromJSON(object) {
    switch (object) {
        case 0:
        case "POSITIONS_UNKNOWN":
            return NamedArmPositionsCommand_Positions.POSITIONS_UNKNOWN;
        case 1:
        case "POSITIONS_CARRY":
            return NamedArmPositionsCommand_Positions.POSITIONS_CARRY;
        case 2:
        case "POSITIONS_READY":
            return NamedArmPositionsCommand_Positions.POSITIONS_READY;
        case 3:
        case "POSITIONS_STOW":
            return NamedArmPositionsCommand_Positions.POSITIONS_STOW;
        case -1:
        case "UNRECOGNIZED":
        default:
            return NamedArmPositionsCommand_Positions.UNRECOGNIZED;
    }
}
exports.namedArmPositionsCommand_PositionsFromJSON = namedArmPositionsCommand_PositionsFromJSON;
function namedArmPositionsCommand_PositionsToJSON(object) {
    switch (object) {
        case NamedArmPositionsCommand_Positions.POSITIONS_UNKNOWN:
            return "POSITIONS_UNKNOWN";
        case NamedArmPositionsCommand_Positions.POSITIONS_CARRY:
            return "POSITIONS_CARRY";
        case NamedArmPositionsCommand_Positions.POSITIONS_READY:
            return "POSITIONS_READY";
        case NamedArmPositionsCommand_Positions.POSITIONS_STOW:
            return "POSITIONS_STOW";
        case NamedArmPositionsCommand_Positions.UNRECOGNIZED:
        default:
            return "UNRECOGNIZED";
    }
}
exports.namedArmPositionsCommand_PositionsToJSON = namedArmPositionsCommand_PositionsToJSON;
var NamedArmPositionsCommand_Feedback_Status;
(function (NamedArmPositionsCommand_Feedback_Status) {
    /** STATUS_UNKNOWN - STATUS_UNKNOWN should never be used. If used, an internal error has happened. */
    NamedArmPositionsCommand_Feedback_Status[NamedArmPositionsCommand_Feedback_Status["STATUS_UNKNOWN"] = 0] = "STATUS_UNKNOWN";
    /** STATUS_COMPLETE - The arm is at the desired configuration. */
    NamedArmPositionsCommand_Feedback_Status[NamedArmPositionsCommand_Feedback_Status["STATUS_COMPLETE"] = 1] = "STATUS_COMPLETE";
    /** STATUS_IN_PROGRESS - Robot is re-configuring arm to get to desired configuration. */
    NamedArmPositionsCommand_Feedback_Status[NamedArmPositionsCommand_Feedback_Status["STATUS_IN_PROGRESS"] = 2] = "STATUS_IN_PROGRESS";
    /**
     * STATUS_STALLED_HOLDING_ITEM - Some positions may refuse to execute if the gripper is holding an item, for example
     * stow.
     */
    NamedArmPositionsCommand_Feedback_Status[NamedArmPositionsCommand_Feedback_Status["STATUS_STALLED_HOLDING_ITEM"] = 3] = "STATUS_STALLED_HOLDING_ITEM";
    NamedArmPositionsCommand_Feedback_Status[NamedArmPositionsCommand_Feedback_Status["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
})(NamedArmPositionsCommand_Feedback_Status = exports.NamedArmPositionsCommand_Feedback_Status || (exports.NamedArmPositionsCommand_Feedback_Status = {}));
function namedArmPositionsCommand_Feedback_StatusFromJSON(object) {
    switch (object) {
        case 0:
        case "STATUS_UNKNOWN":
            return NamedArmPositionsCommand_Feedback_Status.STATUS_UNKNOWN;
        case 1:
        case "STATUS_COMPLETE":
            return NamedArmPositionsCommand_Feedback_Status.STATUS_COMPLETE;
        case 2:
        case "STATUS_IN_PROGRESS":
            return NamedArmPositionsCommand_Feedback_Status.STATUS_IN_PROGRESS;
        case 3:
        case "STATUS_STALLED_HOLDING_ITEM":
            return NamedArmPositionsCommand_Feedback_Status.STATUS_STALLED_HOLDING_ITEM;
        case -1:
        case "UNRECOGNIZED":
        default:
            return NamedArmPositionsCommand_Feedback_Status.UNRECOGNIZED;
    }
}
exports.namedArmPositionsCommand_Feedback_StatusFromJSON = namedArmPositionsCommand_Feedback_StatusFromJSON;
function namedArmPositionsCommand_Feedback_StatusToJSON(object) {
    switch (object) {
        case NamedArmPositionsCommand_Feedback_Status.STATUS_UNKNOWN:
            return "STATUS_UNKNOWN";
        case NamedArmPositionsCommand_Feedback_Status.STATUS_COMPLETE:
            return "STATUS_COMPLETE";
        case NamedArmPositionsCommand_Feedback_Status.STATUS_IN_PROGRESS:
            return "STATUS_IN_PROGRESS";
        case NamedArmPositionsCommand_Feedback_Status.STATUS_STALLED_HOLDING_ITEM:
            return "STATUS_STALLED_HOLDING_ITEM";
        case NamedArmPositionsCommand_Feedback_Status.UNRECOGNIZED:
        default:
            return "UNRECOGNIZED";
    }
}
exports.namedArmPositionsCommand_Feedback_StatusToJSON = namedArmPositionsCommand_Feedback_StatusToJSON;
/**
 * If an axis is set to position mode (default), read desired from SE3Trajectory trajectory
 * command.  If mode is set to Force, read desired from WrenchTrajectory wrench_trajectory
 * command.  This supports hybrid control of the arm where users can specify, for example, Z
 * to be in force control with X and Y in position control.  The elements are expressed in
 * the same task_frame as the trajectories.
 */
var ArmCartesianCommand_Request_AxisMode;
(function (ArmCartesianCommand_Request_AxisMode) {
    ArmCartesianCommand_Request_AxisMode[ArmCartesianCommand_Request_AxisMode["AXIS_MODE_POSITION"] = 0] = "AXIS_MODE_POSITION";
    ArmCartesianCommand_Request_AxisMode[ArmCartesianCommand_Request_AxisMode["AXIS_MODE_FORCE"] = 1] = "AXIS_MODE_FORCE";
    ArmCartesianCommand_Request_AxisMode[ArmCartesianCommand_Request_AxisMode["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
})(ArmCartesianCommand_Request_AxisMode = exports.ArmCartesianCommand_Request_AxisMode || (exports.ArmCartesianCommand_Request_AxisMode = {}));
function armCartesianCommand_Request_AxisModeFromJSON(object) {
    switch (object) {
        case 0:
        case "AXIS_MODE_POSITION":
            return ArmCartesianCommand_Request_AxisMode.AXIS_MODE_POSITION;
        case 1:
        case "AXIS_MODE_FORCE":
            return ArmCartesianCommand_Request_AxisMode.AXIS_MODE_FORCE;
        case -1:
        case "UNRECOGNIZED":
        default:
            return ArmCartesianCommand_Request_AxisMode.UNRECOGNIZED;
    }
}
exports.armCartesianCommand_Request_AxisModeFromJSON = armCartesianCommand_Request_AxisModeFromJSON;
function armCartesianCommand_Request_AxisModeToJSON(object) {
    switch (object) {
        case ArmCartesianCommand_Request_AxisMode.AXIS_MODE_POSITION:
            return "AXIS_MODE_POSITION";
        case ArmCartesianCommand_Request_AxisMode.AXIS_MODE_FORCE:
            return "AXIS_MODE_FORCE";
        case ArmCartesianCommand_Request_AxisMode.UNRECOGNIZED:
        default:
            return "UNRECOGNIZED";
    }
}
exports.armCartesianCommand_Request_AxisModeToJSON = armCartesianCommand_Request_AxisModeToJSON;
var ArmCartesianCommand_Feedback_Status;
(function (ArmCartesianCommand_Feedback_Status) {
    /** STATUS_UNKNOWN - STATUS_UNKNOWN should never be used. If used, an internal error has happened. */
    ArmCartesianCommand_Feedback_Status[ArmCartesianCommand_Feedback_Status["STATUS_UNKNOWN"] = 0] = "STATUS_UNKNOWN";
    /** STATUS_TRAJECTORY_COMPLETE - Tool frame has reached the end of the trajectory within tracking error bounds. */
    ArmCartesianCommand_Feedback_Status[ArmCartesianCommand_Feedback_Status["STATUS_TRAJECTORY_COMPLETE"] = 1] = "STATUS_TRAJECTORY_COMPLETE";
    /** STATUS_IN_PROGRESS - Robot is attempting to reach the target. */
    ArmCartesianCommand_Feedback_Status[ArmCartesianCommand_Feedback_Status["STATUS_IN_PROGRESS"] = 2] = "STATUS_IN_PROGRESS";
    /** STATUS_TRAJECTORY_CANCELLED - Tool frame exceeded maximum allowable tracking error from the desired trajectory. */
    ArmCartesianCommand_Feedback_Status[ArmCartesianCommand_Feedback_Status["STATUS_TRAJECTORY_CANCELLED"] = 3] = "STATUS_TRAJECTORY_CANCELLED";
    /**
     * STATUS_TRAJECTORY_STALLED - The arm has stopped making progress to the goal.  Note, this does not cancel the
     * trajectory. For example, if the requested goal is too far away, walking the base
     * robot closer to the goal will cause the arm to continue along the trajectory once the
     * goal point is inside the workspace.
     */
    ArmCartesianCommand_Feedback_Status[ArmCartesianCommand_Feedback_Status["STATUS_TRAJECTORY_STALLED"] = 4] = "STATUS_TRAJECTORY_STALLED";
    ArmCartesianCommand_Feedback_Status[ArmCartesianCommand_Feedback_Status["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
})(ArmCartesianCommand_Feedback_Status = exports.ArmCartesianCommand_Feedback_Status || (exports.ArmCartesianCommand_Feedback_Status = {}));
function armCartesianCommand_Feedback_StatusFromJSON(object) {
    switch (object) {
        case 0:
        case "STATUS_UNKNOWN":
            return ArmCartesianCommand_Feedback_Status.STATUS_UNKNOWN;
        case 1:
        case "STATUS_TRAJECTORY_COMPLETE":
            return ArmCartesianCommand_Feedback_Status.STATUS_TRAJECTORY_COMPLETE;
        case 2:
        case "STATUS_IN_PROGRESS":
            return ArmCartesianCommand_Feedback_Status.STATUS_IN_PROGRESS;
        case 3:
        case "STATUS_TRAJECTORY_CANCELLED":
            return ArmCartesianCommand_Feedback_Status.STATUS_TRAJECTORY_CANCELLED;
        case 4:
        case "STATUS_TRAJECTORY_STALLED":
            return ArmCartesianCommand_Feedback_Status.STATUS_TRAJECTORY_STALLED;
        case -1:
        case "UNRECOGNIZED":
        default:
            return ArmCartesianCommand_Feedback_Status.UNRECOGNIZED;
    }
}
exports.armCartesianCommand_Feedback_StatusFromJSON = armCartesianCommand_Feedback_StatusFromJSON;
function armCartesianCommand_Feedback_StatusToJSON(object) {
    switch (object) {
        case ArmCartesianCommand_Feedback_Status.STATUS_UNKNOWN:
            return "STATUS_UNKNOWN";
        case ArmCartesianCommand_Feedback_Status.STATUS_TRAJECTORY_COMPLETE:
            return "STATUS_TRAJECTORY_COMPLETE";
        case ArmCartesianCommand_Feedback_Status.STATUS_IN_PROGRESS:
            return "STATUS_IN_PROGRESS";
        case ArmCartesianCommand_Feedback_Status.STATUS_TRAJECTORY_CANCELLED:
            return "STATUS_TRAJECTORY_CANCELLED";
        case ArmCartesianCommand_Feedback_Status.STATUS_TRAJECTORY_STALLED:
            return "STATUS_TRAJECTORY_STALLED";
        case ArmCartesianCommand_Feedback_Status.UNRECOGNIZED:
        default:
            return "UNRECOGNIZED";
    }
}
exports.armCartesianCommand_Feedback_StatusToJSON = armCartesianCommand_Feedback_StatusToJSON;
var ArmJointMoveCommand_Feedback_Status;
(function (ArmJointMoveCommand_Feedback_Status) {
    /** STATUS_UNKNOWN - STATUS_UNKNOWN should never be used. If used, an internal error has happened */
    ArmJointMoveCommand_Feedback_Status[ArmJointMoveCommand_Feedback_Status["STATUS_UNKNOWN"] = 0] = "STATUS_UNKNOWN";
    /** STATUS_COMPLETE - The arm is at the desired configuration. */
    ArmJointMoveCommand_Feedback_Status[ArmJointMoveCommand_Feedback_Status["STATUS_COMPLETE"] = 1] = "STATUS_COMPLETE";
    /** STATUS_IN_PROGRESS - Robot is re-configuring arm to get to desired configuration. */
    ArmJointMoveCommand_Feedback_Status[ArmJointMoveCommand_Feedback_Status["STATUS_IN_PROGRESS"] = 2] = "STATUS_IN_PROGRESS";
    ArmJointMoveCommand_Feedback_Status[ArmJointMoveCommand_Feedback_Status["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
})(ArmJointMoveCommand_Feedback_Status = exports.ArmJointMoveCommand_Feedback_Status || (exports.ArmJointMoveCommand_Feedback_Status = {}));
function armJointMoveCommand_Feedback_StatusFromJSON(object) {
    switch (object) {
        case 0:
        case "STATUS_UNKNOWN":
            return ArmJointMoveCommand_Feedback_Status.STATUS_UNKNOWN;
        case 1:
        case "STATUS_COMPLETE":
            return ArmJointMoveCommand_Feedback_Status.STATUS_COMPLETE;
        case 2:
        case "STATUS_IN_PROGRESS":
            return ArmJointMoveCommand_Feedback_Status.STATUS_IN_PROGRESS;
        case -1:
        case "UNRECOGNIZED":
        default:
            return ArmJointMoveCommand_Feedback_Status.UNRECOGNIZED;
    }
}
exports.armJointMoveCommand_Feedback_StatusFromJSON = armJointMoveCommand_Feedback_StatusFromJSON;
function armJointMoveCommand_Feedback_StatusToJSON(object) {
    switch (object) {
        case ArmJointMoveCommand_Feedback_Status.STATUS_UNKNOWN:
            return "STATUS_UNKNOWN";
        case ArmJointMoveCommand_Feedback_Status.STATUS_COMPLETE:
            return "STATUS_COMPLETE";
        case ArmJointMoveCommand_Feedback_Status.STATUS_IN_PROGRESS:
            return "STATUS_IN_PROGRESS";
        case ArmJointMoveCommand_Feedback_Status.UNRECOGNIZED:
        default:
            return "UNRECOGNIZED";
    }
}
exports.armJointMoveCommand_Feedback_StatusToJSON = armJointMoveCommand_Feedback_StatusToJSON;
var ArmJointMoveCommand_Feedback_PlannerStatus;
(function (ArmJointMoveCommand_Feedback_PlannerStatus) {
    /** PLANNER_STATUS_UNKNOWN - PLANNER_STATUS_UNKNOWN should never be used. If used, an internal error has happened. */
    ArmJointMoveCommand_Feedback_PlannerStatus[ArmJointMoveCommand_Feedback_PlannerStatus["PLANNER_STATUS_UNKNOWN"] = 0] = "PLANNER_STATUS_UNKNOWN";
    /** PLANNER_STATUS_SUCCESS - A solution passing through the desired points and obeying the constraints was found. */
    ArmJointMoveCommand_Feedback_PlannerStatus[ArmJointMoveCommand_Feedback_PlannerStatus["PLANNER_STATUS_SUCCESS"] = 1] = "PLANNER_STATUS_SUCCESS";
    /**
     * PLANNER_STATUS_MODIFIED - The planner had to modify the desired points in order to obey the constraints.  For
     * example, if you specify a 1 point trajectory, and tell it to get there in a really short
     * amount of time, but haven't set a high allowable max velocity / acceleration, the planner
     * will do its best to get as close as possible to the final point, but won't reach it. In
     * situations where we've modified you last point, we append a minimum time trajectory (that
     * obeys the velocity and acceleration limits) from the planner's final point to the requested
     * final point.
     */
    ArmJointMoveCommand_Feedback_PlannerStatus[ArmJointMoveCommand_Feedback_PlannerStatus["PLANNER_STATUS_MODIFIED"] = 2] = "PLANNER_STATUS_MODIFIED";
    /**
     * PLANNER_STATUS_FAILED - Failed to compute a valid trajectory, will go to first point instead. It is possible
     * that our optimizer till fail to solve the problem instead of returning a sub-optimal
     * solution.  This is un-likely to occur.
     */
    ArmJointMoveCommand_Feedback_PlannerStatus[ArmJointMoveCommand_Feedback_PlannerStatus["PLANNER_STATUS_FAILED"] = 3] = "PLANNER_STATUS_FAILED";
    ArmJointMoveCommand_Feedback_PlannerStatus[ArmJointMoveCommand_Feedback_PlannerStatus["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
})(ArmJointMoveCommand_Feedback_PlannerStatus = exports.ArmJointMoveCommand_Feedback_PlannerStatus || (exports.ArmJointMoveCommand_Feedback_PlannerStatus = {}));
function armJointMoveCommand_Feedback_PlannerStatusFromJSON(object) {
    switch (object) {
        case 0:
        case "PLANNER_STATUS_UNKNOWN":
            return ArmJointMoveCommand_Feedback_PlannerStatus.PLANNER_STATUS_UNKNOWN;
        case 1:
        case "PLANNER_STATUS_SUCCESS":
            return ArmJointMoveCommand_Feedback_PlannerStatus.PLANNER_STATUS_SUCCESS;
        case 2:
        case "PLANNER_STATUS_MODIFIED":
            return ArmJointMoveCommand_Feedback_PlannerStatus.PLANNER_STATUS_MODIFIED;
        case 3:
        case "PLANNER_STATUS_FAILED":
            return ArmJointMoveCommand_Feedback_PlannerStatus.PLANNER_STATUS_FAILED;
        case -1:
        case "UNRECOGNIZED":
        default:
            return ArmJointMoveCommand_Feedback_PlannerStatus.UNRECOGNIZED;
    }
}
exports.armJointMoveCommand_Feedback_PlannerStatusFromJSON = armJointMoveCommand_Feedback_PlannerStatusFromJSON;
function armJointMoveCommand_Feedback_PlannerStatusToJSON(object) {
    switch (object) {
        case ArmJointMoveCommand_Feedback_PlannerStatus.PLANNER_STATUS_UNKNOWN:
            return "PLANNER_STATUS_UNKNOWN";
        case ArmJointMoveCommand_Feedback_PlannerStatus.PLANNER_STATUS_SUCCESS:
            return "PLANNER_STATUS_SUCCESS";
        case ArmJointMoveCommand_Feedback_PlannerStatus.PLANNER_STATUS_MODIFIED:
            return "PLANNER_STATUS_MODIFIED";
        case ArmJointMoveCommand_Feedback_PlannerStatus.PLANNER_STATUS_FAILED:
            return "PLANNER_STATUS_FAILED";
        case ArmJointMoveCommand_Feedback_PlannerStatus.UNRECOGNIZED:
        default:
            return "UNRECOGNIZED";
    }
}
exports.armJointMoveCommand_Feedback_PlannerStatusToJSON = armJointMoveCommand_Feedback_PlannerStatusToJSON;
var GazeCommand_Feedback_Status;
(function (GazeCommand_Feedback_Status) {
    /** STATUS_UNKNOWN - STATUS_UNKNOWN should never be used. If used, an internal error has happened. */
    GazeCommand_Feedback_Status[GazeCommand_Feedback_Status["STATUS_UNKNOWN"] = 0] = "STATUS_UNKNOWN";
    /** STATUS_TRAJECTORY_COMPLETE - Robot is gazing at the target at the end of the trajectory. */
    GazeCommand_Feedback_Status[GazeCommand_Feedback_Status["STATUS_TRAJECTORY_COMPLETE"] = 1] = "STATUS_TRAJECTORY_COMPLETE";
    /** STATUS_IN_PROGRESS - Robot is re-configuring arm to gaze at the target. */
    GazeCommand_Feedback_Status[GazeCommand_Feedback_Status["STATUS_IN_PROGRESS"] = 2] = "STATUS_IN_PROGRESS";
    /**
     * STATUS_TOOL_TRAJECTORY_STALLED - The arm has stopped making progress to the goal pose for the tool.
     * Note, this does not cancel the trajectory. For example, if the requested goal is too
     * far away, walking the base robot closer to the goal will cause the arm to continue
     * along the trajectory once it can continue.
     */
    GazeCommand_Feedback_Status[GazeCommand_Feedback_Status["STATUS_TOOL_TRAJECTORY_STALLED"] = 3] = "STATUS_TOOL_TRAJECTORY_STALLED";
    GazeCommand_Feedback_Status[GazeCommand_Feedback_Status["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
})(GazeCommand_Feedback_Status = exports.GazeCommand_Feedback_Status || (exports.GazeCommand_Feedback_Status = {}));
function gazeCommand_Feedback_StatusFromJSON(object) {
    switch (object) {
        case 0:
        case "STATUS_UNKNOWN":
            return GazeCommand_Feedback_Status.STATUS_UNKNOWN;
        case 1:
        case "STATUS_TRAJECTORY_COMPLETE":
            return GazeCommand_Feedback_Status.STATUS_TRAJECTORY_COMPLETE;
        case 2:
        case "STATUS_IN_PROGRESS":
            return GazeCommand_Feedback_Status.STATUS_IN_PROGRESS;
        case 3:
        case "STATUS_TOOL_TRAJECTORY_STALLED":
            return GazeCommand_Feedback_Status.STATUS_TOOL_TRAJECTORY_STALLED;
        case -1:
        case "UNRECOGNIZED":
        default:
            return GazeCommand_Feedback_Status.UNRECOGNIZED;
    }
}
exports.gazeCommand_Feedback_StatusFromJSON = gazeCommand_Feedback_StatusFromJSON;
function gazeCommand_Feedback_StatusToJSON(object) {
    switch (object) {
        case GazeCommand_Feedback_Status.STATUS_UNKNOWN:
            return "STATUS_UNKNOWN";
        case GazeCommand_Feedback_Status.STATUS_TRAJECTORY_COMPLETE:
            return "STATUS_TRAJECTORY_COMPLETE";
        case GazeCommand_Feedback_Status.STATUS_IN_PROGRESS:
            return "STATUS_IN_PROGRESS";
        case GazeCommand_Feedback_Status.STATUS_TOOL_TRAJECTORY_STALLED:
            return "STATUS_TOOL_TRAJECTORY_STALLED";
        case GazeCommand_Feedback_Status.UNRECOGNIZED:
        default:
            return "UNRECOGNIZED";
    }
}
exports.gazeCommand_Feedback_StatusToJSON = gazeCommand_Feedback_StatusToJSON;
function createBaseArmCommand() {
    return {};
}
exports.ArmCommand = {
    encode(_, writer = minimal_1.default.Writer.create()) {
        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 = createBaseArmCommand();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(_) {
        return {};
    },
    toJSON(_) {
        const obj = {};
        return obj;
    },
    fromPartial(_) {
        const message = createBaseArmCommand();
        return message;
    },
};
function createBaseArmCommand_Request() {
    return {
        armCartesianCommand: undefined,
        armJointMoveCommand: undefined,
        namedArmPositionCommand: undefined,
        armVelocityCommand: undefined,
        armGazeCommand: undefined,
        armStopCommand: undefined,
        armDragCommand: undefined,
        params: undefined,
    };
}
exports.ArmCommand_Request = {
    encode(message, writer = minimal_1.default.Writer.create()) {
        if (message.armCartesianCommand !== undefined) {
            exports.ArmCartesianCommand_Request.encode(message.armCartesianCommand, writer.uint32(26).fork()).ldelim();
        }
        if (message.armJointMoveCommand !== undefined) {
            exports.ArmJointMoveCommand_Request.encode(message.armJointMoveCommand, writer.uint32(34).fork()).ldelim();
        }
        if (message.namedArmPositionCommand !== undefined) {
            exports.NamedArmPositionsCommand_Request.encode(message.namedArmPositionCommand, writer.uint32(42).fork()).ldelim();
        }
        if (message.armVelocityCommand !== undefined) {
            exports.ArmVelocityCommand_Request.encode(message.armVelocityCommand, writer.uint32(50).fork()).ldelim();
        }
        if (message.armGazeCommand !== undefined) {
            exports.GazeCommand_Request.encode(message.armGazeCommand, writer.uint32(66).fork()).ldelim();
        }
        if (message.armStopCommand !== undefined) {
            exports.ArmStopCommand_Request.encode(message.armStopCommand, writer.uint32(74).fork()).ldelim();
        }
        if (message.armDragCommand !== undefined) {
            basic_command_1.ArmDragCommand_Request.encode(message.armDragCommand, writer.uint32(82).fork()).ldelim();
        }
        if (message.params !== undefined) {
            exports.ArmParams.encode(message.params, writer.uint32(90).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 = createBaseArmCommand_Request();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 3:
                    message.armCartesianCommand = exports.ArmCartesianCommand_Request.decode(reader, reader.uint32());
                    break;
                case 4:
                    message.armJointMoveCommand = exports.ArmJointMoveCommand_Request.decode(reader, reader.uint32());
                    break;
                case 5:
                    message.namedArmPositionCommand =
                        exports.NamedArmPositionsCommand_Request.decode(reader, reader.uint32());
                    break;
                case 6:
                    message.armVelocityCommand = exports.ArmVelocityCommand_Request.decode(reader, reader.uint32());
                    break;
                case 8:
                    message.armGazeCommand = exports.GazeCommand_Request.decode(reader, reader.uint32());
                    break;
                case 9:
                    message.armStopCommand = exports.ArmStopCommand_Request.decode(reader, reader.uint32());
                    break;
                case 10:
                    message.armDragCommand = basic_command_1.ArmDragCommand_Request.decode(reader, reader.uint32());
                    break;
                case 11:
                    message.params = exports.ArmParams.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            armCartesianCommand: isSet(object.armCartesianCommand)
                ? exports.ArmCartesianCommand_Request.fromJSON(object.armCartesianCommand)
                : undefined,
            armJointMoveCommand: isSet(object.armJointMoveCommand)
                ? exports.ArmJointMoveCommand_Request.fromJSON(object.armJointMoveCommand)
                : undefined,
            namedArmPositionCommand: isSet(object.namedArmPositionCommand)
                ? exports.NamedArmPositionsCommand_Request.fromJSON(object.namedArmPositionCommand)
                : undefined,
            armVelocityCommand: isSet(object.armVelocityCommand)
                ? exports.ArmVelocityCommand_Request.fromJSON(object.armVelocityCommand)
                : undefined,
            armGazeCommand: isSet(object.armGazeCommand)
                ? exports.GazeCommand_Request.fromJSON(object.armGazeCommand)
                : undefined,
            armStopCommand: isSet(object.armStopCommand)
                ? exports.ArmStopCommand_Request.fromJSON(object.armStopCommand)
                : undefined,
            armDragCommand: isSet(object.armDragCommand)
                ? basic_command_1.ArmDragCommand_Request.fromJSON(object.armDragCommand)
                : undefined,
            params: isSet(object.params)
                ? exports.ArmParams.fromJSON(object.params)
                : undefined,
        };
    },
    toJSON(message) {
        const obj = {};
        message.armCartesianCommand !== undefined &&
            (obj.armCartesianCommand = message.armCartesianCommand
                ? exports.ArmCartesianCommand_Request.toJSON(message.armCartesianCommand)
                : undefined);
        message.armJointMoveCommand !== undefined &&
            (obj.armJointMoveCommand = message.armJointMoveCommand
                ? exports.ArmJointMoveCommand_Request.toJSON(message.armJointMoveCommand)
                : undefined);
        message.namedArmPositionCommand !== undefined &&
            (obj.namedArmPositionCommand = message.namedArmPositionCommand
                ? exports.NamedArmPositionsCommand_Request.toJSON(message.namedArmPositionCommand)
                : undefined);
        message.armVelocityCommand !== undefined &&
            (obj.armVelocityCommand = message.armVelocityCommand
                ? exports.ArmVelocityCommand_Request.toJSON(message.armVelocityCommand)
                : undefined);
        message.armGazeCommand !== undefined &&
            (obj.armGazeCommand = message.armGazeCommand
                ? exports.GazeCommand_Request.toJSON(message.armGazeCommand)
                : undefined);
        message.armStopCommand !== undefined &&
            (obj.armStopCommand = message.armStopCommand
                ? exports.ArmStopCommand_Request.toJSON(message.armStopCommand)
                : undefined);
        message.armDragCommand !== undefined &&
            (obj.armDragCommand = message.armDragCommand
                ? basic_command_1.ArmDragCommand_Request.toJSON(message.armDragCommand)
                : undefined);
        message.params !== undefined &&
            (obj.params = message.params
                ? exports.ArmParams.toJSON(message.params)
                : undefined);
        return obj;
    },
    fromPartial(object) {
        const message = createBaseArmCommand_Request();
        message.armCartesianCommand =
            object.armCartesianCommand !== undefined &&
                object.armCartesianCommand !== null
                ? exports.ArmCartesianCommand_Request.fromPartial(object.armCartesianCommand)
                : undefined;
        message.armJointMoveCommand =
            object.armJointMoveCommand !== undefined &&
                object.armJointMoveCommand !== null
                ? exports.ArmJointMoveCommand_Request.fromPartial(object.armJointMoveCommand)
                : undefined;
        message.namedArmPositionCommand =
            object.namedArmPositionCommand !== undefined &&
                object.namedArmPositionCommand !== null
                ? exports.NamedArmPositionsCommand_Request.fromPartial(object.namedArmPositionCommand)
                : undefined;
        message.armVelocityCommand =
            object.armVelocityCommand !== undefined &&
                object.armVelocityCommand !== null
                ? exports.ArmVelocityCommand_Request.fromPartial(object.armVelocityCommand)
                : undefined;
        message.armGazeCommand =
            object.armGazeCommand !== undefined && object.armGazeCommand !== null
                ? exports.GazeCommand_Request.fromPartial(object.armGazeCommand)
                : undefined;
        message.armStopCommand =
            object.armStopCommand !== undefined && object.armStopCommand !== null
                ? exports.ArmStopCommand_Request.fromPartial(object.armStopCommand)
                : undefined;
        message.armDragCommand =
            object.armDragCommand !== undefined && object.armDragCommand !== null
                ? basic_command_1.ArmDragCommand_Request.fromPartial(object.armDragCommand)
                : undefined;
        message.params =
            object.params !== undefined && object.params !== null
                ? exports.ArmParams.fromPartial(object.params)
                : undefined;
        return message;
    },
};
function createBaseArmCommand_Feedback() {
    return {
        armCartesianFeedback: undefined,
        armJointMoveFeedback: undefined,
        namedArmPositionFeedback: undefined,
        armVelocityFeedback: undefined,
        armGazeFeedback: undefined,
        armStopFeedback: undefined,
        armDragFeedback: undefined,
        status: 0,
    };
}
exports.ArmCommand_Feedback = {
    encode(message, writer = minimal_1.default.Writer.create()) {
        if (message.armCartesianFeedback !== undefined) {
            exports.ArmCartesianCommand_Feedback.encode(message.armCartesianFeedback, writer.uint32(26).fork()).ldelim();
        }
        if (message.armJointMoveFeedback !== undefined) {
            exports.ArmJointMoveCommand_Feedback.encode(message.armJointMoveFeedback, writer.uint32(34).fork()).ldelim();
        }
        if (message.namedArmPositionFeedback !== undefined) {
            exports.NamedArmPositionsCommand_Feedback.encode(message.namedArmPositionFeedback, writer.uint32(42).fork()).ldelim();
        }
        if (message.armVelocityFeedback !== undefined) {
            exports.ArmVelocityCommand_Feedback.encode(message.armVelocityFeedback, writer.uint32(50).fork()).ldelim();
        }
        if (message.armGazeFeedback !== undefined) {
            exports.GazeCommand_Feedback.encode(message.armGazeFeedback, writer.uint32(66).fork()).ldelim();
        }
        if (message.armStopFeedback !== undefined) {
            exports.ArmStopCommand_Feedback.encode(message.armStopFeedback, writer.uint32(74).fork()).ldelim();
        }
        if (message.armDragFeedback !== undefined) {
            basic_command_1.ArmDragCommand_Feedback.encode(message.armDragFeedback, writer.uint32(82).fork()).ldelim();
        }
        if (message.status !== 0) {
            writer.uint32(800).int32(message.status);
        }
        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 = createBaseArmCommand_Feedback();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 3:
                    message.armCartesianFeedback = exports.ArmCartesianCommand_Feedback.decode(reader, reader.uint32());
                    break;
                case 4:
                    message.armJointMoveFeedback = exports.ArmJointMoveCommand_Feedback.decode(reader, reader.uint32());
                    break;
                case 5:
                    message.namedArmPositionFeedback =
                        exports.NamedArmPositionsCommand_Feedback.decode(reader, reader.uint32());
                    break;
                case 6:
                    message.armVelocityFeedback = exports.ArmVelocityCommand_Feedback.decode(reader, reader.uint32());
                    break;
                case 8:
                    message.armGazeFeedback = exports.GazeCommand_Feedback.decode(reader, reader.uint32());
                    break;
                case 9:
                    message.armStopFeedback = exports.ArmStopCommand_Feedback.decode(reader, reader.uint32());
                    break;
                case 10:
                    message.armDragFeedback = basic_command_1.ArmDragCommand_Feedback.decode(reader, reader.uint32());
                    break;
                case 100:
                    message.status = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            armCartesianFeedback: isSet(object.armCartesianFeedback)
                ? exports.ArmCartesianCommand_Feedback.fromJSON(object.armCartesianFeedback)
                : undefined,
            armJointMoveFeedback: isSet(object.armJointMoveFeedback)
                ? exports.ArmJointMoveCommand_Feedback.fromJSON(object.armJointMoveFeedback)
                : undefined,
            namedArmPositionFeedback: isSet(object.namedArmPositionFeedback)
                ? exports.NamedArmPositionsCommand_Feedback.fromJSON(object.namedArmPositionFeedback)
                : undefined,
            armVelocityFeedback: isSet(object.armVelocityFeedback)
                ? exports.ArmVelocityCommand_Feedback.fromJSON(object.armVelocityFeedback)
                : undefined,
            armGazeFeedback: isSet(object.armGazeFeedback)
                ? exports.GazeCommand_Feedback.fromJSON(object.armGazeFeedback)
                : undefined,
            armStopFeedback: isSet(object.armStopFeedback)
                ? exports.ArmStopCommand_Feedback.fromJSON(object.armStopFeedback)
                : undefined,
            armDragFeedback: isSet(object.armDragFeedback)
                ? basic_command_1.ArmDragCommand_Feedback.fromJSON(object.armDragFeedback)
                : undefined,
            status: isSet(object.status)
                ? (0, basic_command_1.robotCommandFeedbackStatus_StatusFromJSON)(object.status)
                : 0,
        };
    },
    toJSON(message) {
        const obj = {};
        message.armCartesianFeedback !== undefined &&
            (obj.armCartesianFeedback = message.armCartesianFeedback
                ? exports.ArmCartesianCommand_Feedback.toJSON(message.armCartesianFeedback)
                : undefined);
        message.armJointMoveFeedback !== undefined &&
            (obj.armJointMoveFeedback = message.armJointMoveFeedback
                ? exports.ArmJointMoveCommand_Feedback.toJSON(message.armJointMoveFeedback)
                : undefined);
        message.namedArmPositionFeedback !== undefined &&
            (obj.namedArmPositionFeedback = message.namedArmPositionFeedback
                ? exports.NamedArmPositionsCommand_Feedback.toJSON(message.namedArmPositionFeedback)
                : undefined);
        message.armVelocityFeedback !== undefined &&
            (obj.armVelocityFeedback = message.armVelocityFeedback
                ? exports.ArmVelocityCommand_Feedback.toJSON(message.armVelocityFeedback)
                : undefined);
        message.armGazeFeedback !== undefined &&
            (obj.armGazeFeedback = message.armGazeFeedback
                ? exports.GazeCommand_Feedback.toJSON(message.armGazeFeedback)
                : undefined);
        message.armStopFeedback !== undefined &&
            (obj.armStopFeedback = message.armStopFeedback
                ? exports.ArmStopCommand_Feedback.toJSON(message.armStopFeedback)
                : undefined);
        message.armDragFeedback !== undefined &&
            (obj.armDragFeedback = message.armDragFeedback
                ? basic_command_1.ArmDragCommand_Feedback.toJSON(message.armDragFeedback)
                : undefined);
        message.status !== undefined &&
            (obj.status = (0, basic_command_1.robotCommandFeedbackStatus_StatusToJSON)(message.status));
        return obj;
    },
    fromPartial(object) {
        const message = createBaseArmCommand_Feedback();
        message.armCartesianFeedback =
            object.armCartesianFeedback !== undefined &&
                object.armCartesianFeedback !== null
                ? exports.ArmCartesianCommand_Feedback.fromPartial(object.armCartesianFeedback)
                : undefined;
        message.armJointMoveFeedback =
            object.armJointMoveFeedback !== undefined &&
                object.armJointMoveFeedback !== null
                ? exports.ArmJointMoveCommand_Feedback.fromPartial(object.armJointMoveFeedback)
                : undefined;
        message.namedArmPositionFeedback =
            object.namedArmPositionFeedback !== undefined &&
                object.namedArmPositionFeedback !== null
                ? exports.NamedArmPositionsCommand_Feedback.fromPartial(object.namedArmPositionFeedback)
                : undefined;
        message.armVelocityFeedback =
            object.armVelocityFeedback !== undefined &&
                object.armVelocityFeedback !== null
                ? exports.ArmVelocityCommand_Feedback.fromPartial(object.armVelocityFeedback)
                : undefined;
        message.armGazeFeedback =
            object.armGazeFeedback !== undefined && object.armGazeFeedback !== null
                ? exports.GazeCommand_Feedback.fromPartial(object.armGazeFeedback)
                : undefined;
        message.armStopFeedback =
            object.armStopFeedback !== undefined && object.armStopFeedback !== null
                ? exports.ArmStopCommand_Feedback.fromPartial(object.armStopFeedback)
                : undefined;
        message.armDragFeedback =
            object.armDragFeedback !== undefined && object.armDragFeedback !== null
                ? basic_command_1.ArmDragCommand_Feedback.fromPartial(object.armDragFeedback)
                : undefined;
        message.status = object.status ?? 0;
        return message;
    },
};
function createBaseArmParams() {
    return { disableBodyForceLimiter: undefined };
}
exports.ArmParams = {
    encode(message, writer = minimal_1.default.Writer.create()) {
        if (message.disableBodyForceLimiter !== undefined) {
            wrappers_1.BoolValue.encode({ value: message.disableBodyForceLimiter }, writer.uint32(10).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 = createBaseArmParams();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.disableBodyForceLimiter = wrappers_1.BoolValue.decode(reader, reader.uint32()).value;
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            disableBodyForceLimiter: isSet(object.disableBodyForceLimiter)
                ? Boolean(object.disableBodyForceLimiter)
                : undefined,
        };
    },
    toJSON(message) {
        const obj = {};
        message.disableBodyForceLimiter !== undefined &&
            (obj.disableBodyForceLimiter = message.disableBodyForceLimiter);
        return obj;
    },
    fromPartial(object) {
        const message = createBaseArmParams();
        message.disableBodyForceLimiter =
            object.disableBodyForceLimiter ?? undefined;
        return message;
    },
};
function createBaseArmVelocityCommand() {
    return {};
}
exports.ArmVelocityCommand = {
    encode(_, writer = minimal_1.default.Writer.create()) {
        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 = createBaseArmVelocityCommand();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(_) {
        return {};
    },
    toJSON(_) {
        const obj = {};
        return obj;
    },
    fromPartial(_) {
        const message = createBaseArmVelocityCommand();
        return message;
    },
};
function createBaseArmVelocityCommand_CylindricalVelocity() {
    return { linearVelocity: undefined, maxLinearVelocity: undefined };
}
exports.ArmVelocityCommand_CylindricalVelocity = {
    encode(message, writer = minimal_1.default.Writer.create()) {
        if (message.linearVelocity !== undefined) {
            geometry_1.CylindricalCoordinate.encode(message.linearVelocity, writer.uint32(10).fork()).ldelim();
        }
        if (message.maxLinearVelocity !== undefined) {
            wrappers_1.DoubleValue.encode({ value: message.maxLinearVelocity }, 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 = createBaseArmVelocityCommand_CylindricalVelocity();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.linearVelocity = geometry_1.CylindricalCoordinate.decode(reader, reader.uint32());
                    break;
                case 2:
                    message.maxLinearVelocity = wrappers_1.DoubleValue.decode(reader, reader.uint32()).value;
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            linearVelocity: isSet(object.linearVelocity)
                ? geometry_1.CylindricalCoordinate.fromJSON(object.linearVelocity)
                : undefined,
            maxLinearVelocity: isSet(object.maxLinearVelocity)
                ? Number(object.maxLinearVelocity)
                : undefined,
        };
    },
    toJSON(message) {
        const obj = {};
        message.linearVelocity !== undefined &&
            (obj.linearVelocity = message.linearVelocity
                ? geometry_1.CylindricalCoordinate.toJSON(message.linearVelocity)
                : undefined);
        message.maxLinearVelocity !== undefined &&
            (obj.maxLinearVelocity = message.maxLinearVelocity);
        return obj;
    },
    fromPartial(object) {
        const message = createBaseArmVelocityCommand_CylindricalVelocity();
        message.linearVelocity =
            object.linearVelocity !== undefined && object.linearVelocity !== null
                ? geometry_1.CylindricalCoordinate.fromPartial(object.linearVelocity)
                : undefined;
        message.maxLinearVelocity = object.maxLinearVelocity ?? undefined;
        return message;
    },
};
function createBaseArmVelocityCommand_CartesianVelocity() {
    return { frameName: "", velocityInFrameName: undefined };
}
exports.ArmVelocityCommand_CartesianVelocity = {
    encode(message, writer = minimal_1.default.Writer.create()) {
        if (message.frameName !== "") {
            writer.uint32(10).string(message.frameName);
        }
        if (message.velocityInFrameName !== undefined) {
            geometry_1.Vec3.encode(message.velocityInFrameName, 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 = createBaseArmVelocityCommand_CartesianVelocity();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.frameName = reader.string();
                    break;
                case 2:
                    message.velocityInFrameName = geometry_1.Vec3.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            frameName: isSet(object.frameName) ? String(object.frameName) : "",
            velocityInFrameName: isSet(object.velocityInFrameName)
                ? geometry_1.Vec3.fromJSON(object.velocityInFrameName)
                : undefined,
        };
    },
    toJSON(message) {
        const obj = {};
        message.frameName !==