spot-sdk-ts
Version:
TypeScript bindings based on protobufs (proto3) provided by Boston Dynamics
1,034 lines (1,033 loc) • 61.2 kB
TypeScript
import { SE2Trajectory } from "./trajectory";
import { SE2Velocity, Vec2, Vec3, Wrench } from "./geometry";
import _m0 from "protobufjs/minimal";
export declare const protobufPackage = "bosdyn.api";
export interface RobotCommandFeedbackStatus {
}
export declare enum RobotCommandFeedbackStatus_Status {
/** STATUS_UNKNOWN - / Behavior execution is in an unknown / unexpected state. */
STATUS_UNKNOWN = 0,
/** STATUS_PROCESSING - / The robot is actively working on the command */
STATUS_PROCESSING = 1,
/** STATUS_COMMAND_OVERRIDDEN - / The command was replaced by a new command */
STATUS_COMMAND_OVERRIDDEN = 2,
/** STATUS_COMMAND_TIMED_OUT - / The command expired */
STATUS_COMMAND_TIMED_OUT = 3,
/** STATUS_ROBOT_FROZEN - / The robot is in an unsafe state, and will only respond to known safe commands. */
STATUS_ROBOT_FROZEN = 4,
/**
* STATUS_INCOMPATIBLE_HARDWARE - / The request cannot be executed because the required hardware is missing.
* / For example, an armless robot receiving a synchronized command with an arm_command
* / request will return this value in the arm_command_feedback status.
*/
STATUS_INCOMPATIBLE_HARDWARE = 5,
UNRECOGNIZED = -1
}
export declare function robotCommandFeedbackStatus_StatusFromJSON(object: any): RobotCommandFeedbackStatus_Status;
export declare function robotCommandFeedbackStatus_StatusToJSON(object: RobotCommandFeedbackStatus_Status): string;
/** Get the robot into a convenient pose for changing the battery */
export interface BatteryChangePoseCommand {
}
export interface BatteryChangePoseCommand_Request {
directionHint: BatteryChangePoseCommand_Request_DirectionHint;
}
export declare enum BatteryChangePoseCommand_Request_DirectionHint {
/** HINT_UNKNOWN - Unknown direction, just hold still */
HINT_UNKNOWN = 0,
/** HINT_RIGHT - Roll over right (right feet end up under the robot) */
HINT_RIGHT = 1,
/** HINT_LEFT - Roll over left (left feet end up under the robot) */
HINT_LEFT = 2,
UNRECOGNIZED = -1
}
export declare function batteryChangePoseCommand_Request_DirectionHintFromJSON(object: any): BatteryChangePoseCommand_Request_DirectionHint;
export declare function batteryChangePoseCommand_Request_DirectionHintToJSON(object: BatteryChangePoseCommand_Request_DirectionHint): string;
export interface BatteryChangePoseCommand_Feedback {
status: BatteryChangePoseCommand_Feedback_Status;
}
export declare enum BatteryChangePoseCommand_Feedback_Status {
STATUS_UNKNOWN = 0,
/** STATUS_COMPLETED - Robot is finished rolling */
STATUS_COMPLETED = 1,
/** STATUS_IN_PROGRESS - Robot still in process of rolling over */
STATUS_IN_PROGRESS = 2,
/** STATUS_FAILED - Robot has failed to roll onto its side */
STATUS_FAILED = 3,
UNRECOGNIZED = -1
}
export declare function batteryChangePoseCommand_Feedback_StatusFromJSON(object: any): BatteryChangePoseCommand_Feedback_Status;
export declare function batteryChangePoseCommand_Feedback_StatusToJSON(object: BatteryChangePoseCommand_Feedback_Status): string;
/** Move the robot into a "ready" position from which it can sit or stand up. */
export interface SelfRightCommand {
}
/** SelfRight command request takes no additional arguments. */
export interface SelfRightCommand_Request {
}
export interface SelfRightCommand_Feedback {
status: SelfRightCommand_Feedback_Status;
}
export declare enum SelfRightCommand_Feedback_Status {
STATUS_UNKNOWN = 0,
/** STATUS_COMPLETED - Self-right has completed */
STATUS_COMPLETED = 1,
/** STATUS_IN_PROGRESS - Robot is in progress of attempting to self-right */
STATUS_IN_PROGRESS = 2,
UNRECOGNIZED = -1
}
export declare function selfRightCommand_Feedback_StatusFromJSON(object: any): SelfRightCommand_Feedback_Status;
export declare function selfRightCommand_Feedback_StatusToJSON(object: SelfRightCommand_Feedback_Status): string;
/** Stop the robot in place with minimal motion. */
export interface StopCommand {
}
/** Stop command request takes no additional arguments. */
export interface StopCommand_Request {
}
/** Stop command provides no feedback. */
export interface StopCommand_Feedback {
}
/** Freeze all joints at their current positions (no balancing control). */
export interface FreezeCommand {
}
/** Freeze command request takes no additional arguments. */
export interface FreezeCommand_Request {
}
/** Freeze command provides no feedback. */
export interface FreezeCommand_Feedback {
}
/**
* Get robot into a position where it is safe to power down, then power down. If the robot has
* fallen, it will power down directly. If the robot is standing, it will first sit then power down.
* With appropriate request parameters and under limited scenarios, the robot may take additional
* steps to move to a safe position. The robot will not power down until it is in a sitting state.
*/
export interface SafePowerOffCommand {
}
export interface SafePowerOffCommand_Request {
unsafeAction: SafePowerOffCommand_Request_UnsafeAction;
}
/**
* Robot action in response to a command received while in an unsafe position. If not
* specified, UNSAFE_MOVE_TO_SAFE_POSITION will be used
*/
export declare enum SafePowerOffCommand_Request_UnsafeAction {
UNSAFE_UNKNOWN = 0,
/**
* UNSAFE_MOVE_TO_SAFE_POSITION - Robot may attempt to move to a safe position (i.e. descends stairs) before sitting
* and powering off.
*/
UNSAFE_MOVE_TO_SAFE_POSITION = 1,
/** UNSAFE_FORCE_COMMAND - Force sit and power off regardless of positioning. Robot will not take additional steps */
UNSAFE_FORCE_COMMAND = 2,
UNRECOGNIZED = -1
}
export declare function safePowerOffCommand_Request_UnsafeActionFromJSON(object: any): SafePowerOffCommand_Request_UnsafeAction;
export declare function safePowerOffCommand_Request_UnsafeActionToJSON(object: SafePowerOffCommand_Request_UnsafeAction): string;
/**
* The SafePowerOff will provide feedback on whether or not it has succeeded in powering off
* the robot yet.
*/
export interface SafePowerOffCommand_Feedback {
/** Current status of the command. */
status: SafePowerOffCommand_Feedback_Status;
}
export declare enum SafePowerOffCommand_Feedback_Status {
/** STATUS_UNKNOWN - STATUS_UNKNOWN should never be used. If used, an internal error has happened. */
STATUS_UNKNOWN = 0,
/** STATUS_POWERED_OFF - Robot has powered off. */
STATUS_POWERED_OFF = 1,
/** STATUS_IN_PROGRESS - Robot is trying to safely power off. */
STATUS_IN_PROGRESS = 2,
UNRECOGNIZED = -1
}
export declare function safePowerOffCommand_Feedback_StatusFromJSON(object: any): SafePowerOffCommand_Feedback_Status;
export declare function safePowerOffCommand_Feedback_StatusToJSON(object: SafePowerOffCommand_Feedback_Status): string;
/** Move along a trajectory in 2D space. */
export interface SE2TrajectoryCommand {
}
export interface SE2TrajectoryCommand_Request {
/**
* The timestamp (in robot time) by which a command must finish executing.
* This is a required field and used to prevent runaway commands.
*/
endTime: Date | undefined;
/**
* The name of the frame that trajectory is relative to. The trajectory
* must be expressed in a gravity aligned frame, so either "vision",
* "odom", or "body". Any other provided se2_frame_name will be rejected
* and the trajectory command will not be exectuted.
*/
se2FrameName: string;
/**
* The trajectory that the robot should follow, expressed in the frame
* identified by se2_frame_name.
*/
trajectory: SE2Trajectory | undefined;
}
/**
* The SE2TrajectoryCommand will provide feedback on whether or not the robot has reached the
* final point of the trajectory.
*/
export interface SE2TrajectoryCommand_Feedback {
/** Current status of the command. */
status: SE2TrajectoryCommand_Feedback_Status;
/** Current status of how the body is moving */
bodyMovementStatus: SE2TrajectoryCommand_Feedback_BodyMovementStatus;
}
export declare enum SE2TrajectoryCommand_Feedback_Status {
/** STATUS_UNKNOWN - STATUS_UNKNOWN should never be used. If used, an internal error has happened. */
STATUS_UNKNOWN = 0,
/** STATUS_AT_GOAL - The robot has arrived and is standing at the goal. */
STATUS_AT_GOAL = 1,
/** STATUS_NEAR_GOAL - The robot has arrived at the goal and is doing final positioning. */
STATUS_NEAR_GOAL = 3,
/** STATUS_GOING_TO_GOAL - The robot is attempting to go to a goal. */
STATUS_GOING_TO_GOAL = 2,
UNRECOGNIZED = -1
}
export declare function sE2TrajectoryCommand_Feedback_StatusFromJSON(object: any): SE2TrajectoryCommand_Feedback_Status;
export declare function sE2TrajectoryCommand_Feedback_StatusToJSON(object: SE2TrajectoryCommand_Feedback_Status): string;
export declare enum SE2TrajectoryCommand_Feedback_BodyMovementStatus {
/** BODY_STATUS_UNKNOWN - STATUS_UNKNOWN should never be used. If used, an internal error has happened. */
BODY_STATUS_UNKNOWN = 0,
/** BODY_STATUS_MOVING - The robot body is not settled at the goal. */
BODY_STATUS_MOVING = 1,
/** BODY_STATUS_SETTLED - The robot is at the goal and the body has stopped moving. */
BODY_STATUS_SETTLED = 2,
UNRECOGNIZED = -1
}
export declare function sE2TrajectoryCommand_Feedback_BodyMovementStatusFromJSON(object: any): SE2TrajectoryCommand_Feedback_BodyMovementStatus;
export declare function sE2TrajectoryCommand_Feedback_BodyMovementStatusToJSON(object: SE2TrajectoryCommand_Feedback_BodyMovementStatus): string;
/** Move the robot at a specific SE2 velocity for a fixed amount of time. */
export interface SE2VelocityCommand {
}
export interface SE2VelocityCommand_Request {
/**
* The timestamp (in robot time) by which a command must finish executing. This is a
* required field and used to prevent runaway commands.
*/
endTime: Date | undefined;
/**
* The name of the frame that velocity and slew_rate_limit are relative to.
* The trajectory must be expressed in a gravity aligned frame, so either
* "vision", "odom", or "flat_body". Any other provided
* se2_frame_name will be rejected and the velocity command will not be executed.
*/
se2FrameName: string;
/** Desired planar velocity of the robot body relative to se2_frame_name. */
velocity: SE2Velocity | undefined;
/**
* If set, limits how quickly velocity can change relative to se2_frame_name.
* Otherwise, robot may decide to limit velocities using default settings.
* These values should be non-negative.
*/
slewRateLimit: SE2Velocity | undefined;
}
/** Planar velocity commands provide no feedback. */
export interface SE2VelocityCommand_Feedback {
}
/** Sit the robot down in its current position. */
export interface SitCommand {
}
/** Sit command request takes no additional arguments. */
export interface SitCommand_Request {
}
export interface SitCommand_Feedback {
/** Current status of the command. */
status: SitCommand_Feedback_Status;
}
export declare enum SitCommand_Feedback_Status {
/** STATUS_UNKNOWN - STATUS_UNKNOWN should never be used. If used, an internal error has happened. */
STATUS_UNKNOWN = 0,
/** STATUS_IS_SITTING - Robot is currently sitting. */
STATUS_IS_SITTING = 1,
/** STATUS_IN_PROGRESS - Robot is trying to sit. */
STATUS_IN_PROGRESS = 2,
UNRECOGNIZED = -1
}
export declare function sitCommand_Feedback_StatusFromJSON(object: any): SitCommand_Feedback_Status;
export declare function sitCommand_Feedback_StatusToJSON(object: SitCommand_Feedback_Status): string;
/** The stand the robot up in its current position. */
export interface StandCommand {
}
/** Stand command request takes no additional arguments. */
export interface StandCommand_Request {
}
/**
* The StandCommand will provide two feedback fields: status, and standing_state. Status
* reflects if the robot has four legs on the ground and is near a final pose. StandingState
* reflects if the robot has converged to a final pose and does not expect future movement.
*/
export interface StandCommand_Feedback {
/** Current status of the command. */
status: StandCommand_Feedback_Status;
/** What type of standing the robot is doing currently. */
standingState: StandCommand_Feedback_StandingState;
}
export declare enum StandCommand_Feedback_Status {
/** STATUS_UNKNOWN - STATUS_UNKNOWN should never be used. If used, an internal error has happened. */
STATUS_UNKNOWN = 0,
/** STATUS_IS_STANDING - Robot has finished standing up and has completed desired body trajectory. */
STATUS_IS_STANDING = 1,
/** STATUS_IN_PROGRESS - Robot is trying to come to a steady stand. */
STATUS_IN_PROGRESS = 2,
UNRECOGNIZED = -1
}
export declare function standCommand_Feedback_StatusFromJSON(object: any): StandCommand_Feedback_Status;
export declare function standCommand_Feedback_StatusToJSON(object: StandCommand_Feedback_Status): string;
export declare enum StandCommand_Feedback_StandingState {
/** STANDING_UNKNOWN - STANDING_UNKNOWN should never be used. If used, an internal error has happened. */
STANDING_UNKNOWN = 0,
/**
* STANDING_CONTROLLED - Robot is standing up and actively controlling its body so it may occasionally make
* small body adjustments.
*/
STANDING_CONTROLLED = 1,
/**
* STANDING_FROZEN - Robot is standing still with its body frozen in place so it should not move unless
* commanded to. Motion sensitive tasks like laser scanning should be performed in this
* state.
*/
STANDING_FROZEN = 2,
UNRECOGNIZED = -1
}
export declare function standCommand_Feedback_StandingStateFromJSON(object: any): StandCommand_Feedback_StandingState;
export declare function standCommand_Feedback_StandingStateToJSON(object: StandCommand_Feedback_StandingState): string;
/**
* Precise foot placement
* This can be used to reposition the robots feet in place.
*/
export interface StanceCommand {
}
export interface StanceCommand_Request {
/**
* / The timestamp (in robot time) by which a command must finish executing.
* / This is a required field and used to prevent runaway commands.
*/
endTime: Date | undefined;
stance: Stance | undefined;
}
export interface StanceCommand_Feedback {
status: StanceCommand_Feedback_Status;
}
export declare enum StanceCommand_Feedback_Status {
STATUS_UNKNOWN = 0,
/** STATUS_STANCED - Robot has finished moving feet and they are at the specified position */
STATUS_STANCED = 1,
/** STATUS_GOING_TO_STANCE - Robot is in the process of moving feet to specified position */
STATUS_GOING_TO_STANCE = 2,
/**
* STATUS_TOO_FAR_AWAY - Robot is not moving, the specified stance was too far away.
* Hint: Try using SE2TrajectoryCommand to safely put the robot at the
* correct location first.
*/
STATUS_TOO_FAR_AWAY = 3,
UNRECOGNIZED = -1
}
export declare function stanceCommand_Feedback_StatusFromJSON(object: any): StanceCommand_Feedback_Status;
export declare function stanceCommand_Feedback_StatusToJSON(object: StanceCommand_Feedback_Status): string;
export interface Stance {
/** The frame name which the desired foot_positions are described in. */
se2FrameName: string;
/**
* Map of foot name to its x,y location in specified frame.
* Required positions for spot: "fl", "fr", "hl", "hr".
*/
footPositions: {
[key: string]: Vec2;
};
/**
* Required foot positional accuracy in meters
* Advised = 0.05 ( 5cm)
* Minimum = 0.02 ( 2cm)
* Maximum = 0.10 (10cm)
*/
accuracy: number;
}
export interface Stance_FootPositionsEntry {
key: string;
value: Vec2 | undefined;
}
/**
* The base will move in response to the hand's location, allow the arm to reach beyond
* its current workspace. If the hand is moved forward, the body will begin walking
* forward to keep the base at the desired offset from the hand.
*/
export interface FollowArmCommand {
}
export interface FollowArmCommand_Request {
/**
* Optional body offset from the hand.
* For example, to have the body 0.75 meters behind the hand, use (0.75, 0, 0)
*/
bodyOffsetFromHand: Vec3 | undefined;
/**
* DEPRECATED as of 3.1.
* To reproduce the robot's behavior of disable_walking == true,
* issue a StandCommand setting the enable_body_yaw_assist_for_manipulation and
* enable_hip_height_assist_for_manipulation MobilityParams to true. Any combination
* of the enable_*_for_manipulation are accepted in stand giving finer control of
* the robot's behavior.
*
* @deprecated
*/
disableWalking: boolean;
}
/** FollowArmCommand commands provide no feedback. */
export interface FollowArmCommand_Feedback {
}
export interface ArmDragCommand {
}
export interface ArmDragCommand_Request {
}
export interface ArmDragCommand_Feedback {
status: ArmDragCommand_Feedback_Status;
}
export declare enum ArmDragCommand_Feedback_Status {
/** STATUS_UNKNOWN - STATUS_UNKNOWN should never be used. If used, an internal error has happened. */
STATUS_UNKNOWN = 0,
/** STATUS_DRAGGING - Robot is dragging. */
STATUS_DRAGGING = 1,
/**
* STATUS_GRASP_FAILED - Robot is not dragging because grasp failed.
* This could be due to a lost grasp during a drag, or because the gripper isn't in a good
* position at the time of request. You'll have to reposition or regrasp and then send a
* new drag request to overcome this type of error.
* Note: When requesting drag, make sure the gripper is positioned in front of the robot (not to the side of or
* above the robot body).
*/
STATUS_GRASP_FAILED = 2,
/**
* STATUS_OTHER_FAILURE - Robot is not dragging for another reason.
* This might be because the gripper isn't holding an item.
* You can continue dragging once you resolve this type of error (i.e. by sending an ApiGraspOverride request).
* Note: When requesting drag, be sure to that the robot knows it's holding something (or use APIGraspOverride to
* OVERRIDE_HOLDING).
*/
STATUS_OTHER_FAILURE = 3,
UNRECOGNIZED = -1
}
export declare function armDragCommand_Feedback_StatusFromJSON(object: any): ArmDragCommand_Feedback_Status;
export declare function armDragCommand_Feedback_StatusToJSON(object: ArmDragCommand_Feedback_Status): string;
export interface ConstrainedManipulationCommand {
}
export interface ConstrainedManipulationCommand_Request {
/** Frame that the initial wrench will be expressed in */
frameName: string;
/**
* Direction of the initial wrench to be applied
* Depending on the task, either the force vector or the
* torque vector are required to be specified. The required
* vector should not have a magnitude of zero and will be
* normalized to 1. For tasks that require the force vector,
* the torque vector can still be specified as a non-zero vector
* if it is a good guess of the axis of rotation of the task.
* (for e.g. TASK_TYPE_SE3_ROTATIONAL_TORQUE task types.)
* Note that if both vectors are non-zero, they have to be perpendicular.
* Once the constrained manipulation system estimates the
* constraint, the init_wrench_direction and frame_name
* will no longer be used.
*/
initWrenchDirectionInFrameName: Wrench | undefined;
/** Recommended values are in the range of [-4, 4] m/s */
tangentialSpeed: number | undefined;
/** Recommended values are in the range of [-4, 4] rad/s */
rotationalSpeed: number | undefined;
/**
* The limit on the force that is applied on any translation direction
* Value must be positive
* If unspecified, a default value of 40 N will be used.
*/
forceLimit: number | undefined;
/**
* The limit on the torque that is applied on any rotational direction
* Value must be positive
* If unspecified, a default value of 4 Nm will be used.
*/
torqueLimit: number | undefined;
taskType: ConstrainedManipulationCommand_Request_TaskType;
/**
* The timestamp (in robot time) by which a command must finish executing.
* This is a required field and used to prevent runaway commands.
*/
endTime: Date | undefined;
/** Whether to enable the robot to take steps during constrained manip to keep the hand in the workspace. */
enableRobotLocomotion: boolean | undefined;
}
/**
* Geometrical category of a task. See the constrained_manipulation_helper function
* for examples of each of these categories. For e.g. SE3_CIRCLE_FORCE_TORQUE corresponds
* to lever type objects.
*/
export declare enum ConstrainedManipulationCommand_Request_TaskType {
TASK_TYPE_UNKNOWN = 0,
/**
* TASK_TYPE_SE3_CIRCLE_FORCE_TORQUE - This task type corresponds to circular tasks where
* both the end-effector position and orientation rotate about a circle to manipulate.
* The constrained manipulation logic will generate forces and torques in this case.
* Example tasks are: A lever or a ball valve with a solid grasp
* This task type will require an initial force vector specified
* in init_wrench_direction_in_frame_name. A torque vector can be specified
* as well if a good initial guess of the axis of rotation of the task is available.
*/
TASK_TYPE_SE3_CIRCLE_FORCE_TORQUE = 1,
/**
* TASK_TYPE_R3_CIRCLE_EXTRADOF_FORCE - This task type corresponds to circular tasks that have an extra degree of freedom.
* In these tasks the end-effector position rotates about a circle
* but the orientation does not need to follow a circle (can remain fixed).
* The constrained manipulation logic will generate translational forces in this case.
* Example tasks are: A crank that has a loose handle and moves in a circle
* and the end-effector is free to rotate about the handle in one direction.
* This task type will require an initial force vector specified
* in init_wrench_direction_in_frame_name.
*/
TASK_TYPE_R3_CIRCLE_EXTRADOF_FORCE = 2,
/**
* TASK_TYPE_SE3_ROTATIONAL_TORQUE - This task type corresponds to purely rotational tasks.
* In these tasks the orientation of the end-effector follows a circle,
* and the position remains fixed. The robot will apply a torque at the
* end-effector in these tasks.
* Example tasks are: rotating a knob or valve that does not have a lever arm.
* This task type will require an initial torque vector specified
* in init_wrench_direction_in_frame_name.
*/
TASK_TYPE_SE3_ROTATIONAL_TORQUE = 3,
/**
* TASK_TYPE_R3_CIRCLE_FORCE - This task type corresponds to circular tasks where
* the end-effector position and orientation rotate about a circle
* but the orientation does always strictly follow the circle due to slips.
* The constrained manipulation logic will generate translational forces in this case.
* Example tasks are: manipulating a cabinet where the grasp on handle is not very rigid
* or can often slip.
* This task type will require an initial force vector specified
* in init_wrench_direction_in_frame_name.
*/
TASK_TYPE_R3_CIRCLE_FORCE = 4,
/**
* TASK_TYPE_R3_LINEAR_FORCE - This task type corresponds to linear tasks where
* the end-effector position moves in a line
* but the orientation does not need to change.
* The constrained manipulation logic will generate a force in this case.
* Example tasks are: A crank that has a loose handle, or manipulating
* a cabinet where the grasp of the handle is loose and the end-effector is free
* to rotate about the handle in one direction.
* This task type will require an initial force vector specified
* in init_wrench_direction_in_frame_name.
*/
TASK_TYPE_R3_LINEAR_FORCE = 5,
/**
* TASK_TYPE_HOLD_POSE - This option simply holds the hand in place with stiff impedance control.
* You can use this mode at the beginning of a constrained manipulation task or to
* hold position while transitioning between two different constrained manipulation tasks.
* The target pose to hold will be the measured hand pose upon transitioning to constrained
* manipulation or upon switching to this task type.
* This mode should only be used during constrained manipulation tasks,
* since it uses impedance control to hold the hand in place.
* This is not intended to stop the arm during position control moves.
*/
TASK_TYPE_HOLD_POSE = 6,
UNRECOGNIZED = -1
}
export declare function constrainedManipulationCommand_Request_TaskTypeFromJSON(object: any): ConstrainedManipulationCommand_Request_TaskType;
export declare function constrainedManipulationCommand_Request_TaskTypeToJSON(object: ConstrainedManipulationCommand_Request_TaskType): string;
export interface ConstrainedManipulationCommand_Feedback {
status: ConstrainedManipulationCommand_Feedback_Status;
/** Desired wrench in odom world frame, applied at hand frame origin */
desiredWrenchOdomFrame: Wrench | undefined;
}
export declare enum ConstrainedManipulationCommand_Feedback_Status {
/** STATUS_UNKNOWN - STATUS_UNKNOWN should never be used. If used, an internal error has happened. */
STATUS_UNKNOWN = 0,
/** STATUS_RUNNING - Constrained manipulation is working as expected */
STATUS_RUNNING = 1,
/**
* STATUS_ARM_IS_STUCK - Arm is stuck, either force is being applied in a direction
* where the affordance can't move or not enough force is applied
*/
STATUS_ARM_IS_STUCK = 2,
/**
* STATUS_GRASP_IS_LOST - The grasp was lost. In this situation, constrained manipulation
* will stop applying force, and will hold the last position.
*/
STATUS_GRASP_IS_LOST = 3,
UNRECOGNIZED = -1
}
export declare function constrainedManipulationCommand_Feedback_StatusFromJSON(object: any): ConstrainedManipulationCommand_Feedback_Status;
export declare function constrainedManipulationCommand_Feedback_StatusToJSON(object: ConstrainedManipulationCommand_Feedback_Status): string;
export declare const RobotCommandFeedbackStatus: {
encode(_: RobotCommandFeedbackStatus, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): RobotCommandFeedbackStatus;
fromJSON(_: any): RobotCommandFeedbackStatus;
toJSON(_: RobotCommandFeedbackStatus): unknown;
fromPartial<I extends {} & {} & { [K in Exclude<keyof I, never>]: never; }>(_: I): RobotCommandFeedbackStatus;
};
export declare const BatteryChangePoseCommand: {
encode(_: BatteryChangePoseCommand, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): BatteryChangePoseCommand;
fromJSON(_: any): BatteryChangePoseCommand;
toJSON(_: BatteryChangePoseCommand): unknown;
fromPartial<I extends {} & {} & { [K in Exclude<keyof I, never>]: never; }>(_: I): BatteryChangePoseCommand;
};
export declare const BatteryChangePoseCommand_Request: {
encode(message: BatteryChangePoseCommand_Request, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): BatteryChangePoseCommand_Request;
fromJSON(object: any): BatteryChangePoseCommand_Request;
toJSON(message: BatteryChangePoseCommand_Request): unknown;
fromPartial<I extends {
directionHint?: BatteryChangePoseCommand_Request_DirectionHint | undefined;
} & {
directionHint?: BatteryChangePoseCommand_Request_DirectionHint | undefined;
} & { [K in Exclude<keyof I, "directionHint">]: never; }>(object: I): BatteryChangePoseCommand_Request;
};
export declare const BatteryChangePoseCommand_Feedback: {
encode(message: BatteryChangePoseCommand_Feedback, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): BatteryChangePoseCommand_Feedback;
fromJSON(object: any): BatteryChangePoseCommand_Feedback;
toJSON(message: BatteryChangePoseCommand_Feedback): unknown;
fromPartial<I extends {
status?: BatteryChangePoseCommand_Feedback_Status | undefined;
} & {
status?: BatteryChangePoseCommand_Feedback_Status | undefined;
} & { [K in Exclude<keyof I, "status">]: never; }>(object: I): BatteryChangePoseCommand_Feedback;
};
export declare const SelfRightCommand: {
encode(_: SelfRightCommand, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): SelfRightCommand;
fromJSON(_: any): SelfRightCommand;
toJSON(_: SelfRightCommand): unknown;
fromPartial<I extends {} & {} & { [K in Exclude<keyof I, never>]: never; }>(_: I): SelfRightCommand;
};
export declare const SelfRightCommand_Request: {
encode(_: SelfRightCommand_Request, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): SelfRightCommand_Request;
fromJSON(_: any): SelfRightCommand_Request;
toJSON(_: SelfRightCommand_Request): unknown;
fromPartial<I extends {} & {} & { [K in Exclude<keyof I, never>]: never; }>(_: I): SelfRightCommand_Request;
};
export declare const SelfRightCommand_Feedback: {
encode(message: SelfRightCommand_Feedback, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): SelfRightCommand_Feedback;
fromJSON(object: any): SelfRightCommand_Feedback;
toJSON(message: SelfRightCommand_Feedback): unknown;
fromPartial<I extends {
status?: SelfRightCommand_Feedback_Status | undefined;
} & {
status?: SelfRightCommand_Feedback_Status | undefined;
} & { [K in Exclude<keyof I, "status">]: never; }>(object: I): SelfRightCommand_Feedback;
};
export declare const StopCommand: {
encode(_: StopCommand, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): StopCommand;
fromJSON(_: any): StopCommand;
toJSON(_: StopCommand): unknown;
fromPartial<I extends {} & {} & { [K in Exclude<keyof I, never>]: never; }>(_: I): StopCommand;
};
export declare const StopCommand_Request: {
encode(_: StopCommand_Request, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): StopCommand_Request;
fromJSON(_: any): StopCommand_Request;
toJSON(_: StopCommand_Request): unknown;
fromPartial<I extends {} & {} & { [K in Exclude<keyof I, never>]: never; }>(_: I): StopCommand_Request;
};
export declare const StopCommand_Feedback: {
encode(_: StopCommand_Feedback, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): StopCommand_Feedback;
fromJSON(_: any): StopCommand_Feedback;
toJSON(_: StopCommand_Feedback): unknown;
fromPartial<I extends {} & {} & { [K in Exclude<keyof I, never>]: never; }>(_: I): StopCommand_Feedback;
};
export declare const FreezeCommand: {
encode(_: FreezeCommand, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): FreezeCommand;
fromJSON(_: any): FreezeCommand;
toJSON(_: FreezeCommand): unknown;
fromPartial<I extends {} & {} & { [K in Exclude<keyof I, never>]: never; }>(_: I): FreezeCommand;
};
export declare const FreezeCommand_Request: {
encode(_: FreezeCommand_Request, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): FreezeCommand_Request;
fromJSON(_: any): FreezeCommand_Request;
toJSON(_: FreezeCommand_Request): unknown;
fromPartial<I extends {} & {} & { [K in Exclude<keyof I, never>]: never; }>(_: I): FreezeCommand_Request;
};
export declare const FreezeCommand_Feedback: {
encode(_: FreezeCommand_Feedback, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): FreezeCommand_Feedback;
fromJSON(_: any): FreezeCommand_Feedback;
toJSON(_: FreezeCommand_Feedback): unknown;
fromPartial<I extends {} & {} & { [K in Exclude<keyof I, never>]: never; }>(_: I): FreezeCommand_Feedback;
};
export declare const SafePowerOffCommand: {
encode(_: SafePowerOffCommand, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): SafePowerOffCommand;
fromJSON(_: any): SafePowerOffCommand;
toJSON(_: SafePowerOffCommand): unknown;
fromPartial<I extends {} & {} & { [K in Exclude<keyof I, never>]: never; }>(_: I): SafePowerOffCommand;
};
export declare const SafePowerOffCommand_Request: {
encode(message: SafePowerOffCommand_Request, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): SafePowerOffCommand_Request;
fromJSON(object: any): SafePowerOffCommand_Request;
toJSON(message: SafePowerOffCommand_Request): unknown;
fromPartial<I extends {
unsafeAction?: SafePowerOffCommand_Request_UnsafeAction | undefined;
} & {
unsafeAction?: SafePowerOffCommand_Request_UnsafeAction | undefined;
} & { [K in Exclude<keyof I, "unsafeAction">]: never; }>(object: I): SafePowerOffCommand_Request;
};
export declare const SafePowerOffCommand_Feedback: {
encode(message: SafePowerOffCommand_Feedback, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): SafePowerOffCommand_Feedback;
fromJSON(object: any): SafePowerOffCommand_Feedback;
toJSON(message: SafePowerOffCommand_Feedback): unknown;
fromPartial<I extends {
status?: SafePowerOffCommand_Feedback_Status | undefined;
} & {
status?: SafePowerOffCommand_Feedback_Status | undefined;
} & { [K in Exclude<keyof I, "status">]: never; }>(object: I): SafePowerOffCommand_Feedback;
};
export declare const SE2TrajectoryCommand: {
encode(_: SE2TrajectoryCommand, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): SE2TrajectoryCommand;
fromJSON(_: any): SE2TrajectoryCommand;
toJSON(_: SE2TrajectoryCommand): unknown;
fromPartial<I extends {} & {} & { [K in Exclude<keyof I, never>]: never; }>(_: I): SE2TrajectoryCommand;
};
export declare const SE2TrajectoryCommand_Request: {
encode(message: SE2TrajectoryCommand_Request, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): SE2TrajectoryCommand_Request;
fromJSON(object: any): SE2TrajectoryCommand_Request;
toJSON(message: SE2TrajectoryCommand_Request): unknown;
fromPartial<I extends {
endTime?: Date | undefined;
se2FrameName?: string | undefined;
trajectory?: {
points?: {
pose?: {
position?: {
x?: number | undefined;
y?: number | undefined;
} | undefined;
angle?: number | undefined;
} | undefined;
timeSinceReference?: {
seconds?: number | undefined;
nanos?: number | undefined;
} | undefined;
}[] | undefined;
referenceTime?: Date | undefined;
interpolation?: import("./trajectory").PositionalInterpolation | undefined;
} | undefined;
} & {
endTime?: Date | undefined;
se2FrameName?: string | undefined;
trajectory?: ({
points?: {
pose?: {
position?: {
x?: number | undefined;
y?: number | undefined;
} | undefined;
angle?: number | undefined;
} | undefined;
timeSinceReference?: {
seconds?: number | undefined;
nanos?: number | undefined;
} | undefined;
}[] | undefined;
referenceTime?: Date | undefined;
interpolation?: import("./trajectory").PositionalInterpolation | undefined;
} & {
points?: ({
pose?: {
position?: {
x?: number | undefined;
y?: number | undefined;
} | undefined;
angle?: number | undefined;
} | undefined;
timeSinceReference?: {
seconds?: number | undefined;
nanos?: number | undefined;
} | undefined;
}[] & ({
pose?: {
position?: {
x?: number | undefined;
y?: number | undefined;
} | undefined;
angle?: number | undefined;
} | undefined;
timeSinceReference?: {
seconds?: number | undefined;
nanos?: number | undefined;
} | undefined;
} & {
pose?: ({
position?: {
x?: number | undefined;
y?: number | undefined;
} | undefined;
angle?: number | undefined;
} & {
position?: ({
x?: number | undefined;
y?: number | undefined;
} & {
x?: number | undefined;
y?: number | undefined;
} & { [K in Exclude<keyof I["trajectory"]["points"][number]["pose"]["position"], keyof Vec2>]: never; }) | undefined;
angle?: number | undefined;
} & { [K_1 in Exclude<keyof I["trajectory"]["points"][number]["pose"], keyof import("./geometry").SE2Pose>]: never; }) | undefined;
timeSinceReference?: ({
seconds?: number | undefined;
nanos?: number | undefined;
} & {
seconds?: number | undefined;
nanos?: number | undefined;
} & { [K_2 in Exclude<keyof I["trajectory"]["points"][number]["timeSinceReference"], keyof import("../../google/protobuf/duration").Duration>]: never; }) | undefined;
} & { [K_3 in Exclude<keyof I["trajectory"]["points"][number], keyof import("./trajectory").SE2TrajectoryPoint>]: never; })[] & { [K_4 in Exclude<keyof I["trajectory"]["points"], keyof {
pose?: {
position?: {
x?: number | undefined;
y?: number | undefined;
} | undefined;
angle?: number | undefined;
} | undefined;
timeSinceReference?: {
seconds?: number | undefined;
nanos?: number | undefined;
} | undefined;
}[]>]: never; }) | undefined;
referenceTime?: Date | undefined;
interpolation?: import("./trajectory").PositionalInterpolation | undefined;
} & { [K_5 in Exclude<keyof I["trajectory"], keyof SE2Trajectory>]: never; }) | undefined;
} & { [K_6 in Exclude<keyof I, keyof SE2TrajectoryCommand_Request>]: never; }>(object: I): SE2TrajectoryCommand_Request;
};
export declare const SE2TrajectoryCommand_Feedback: {
encode(message: SE2TrajectoryCommand_Feedback, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): SE2TrajectoryCommand_Feedback;
fromJSON(object: any): SE2TrajectoryCommand_Feedback;
toJSON(message: SE2TrajectoryCommand_Feedback): unknown;
fromPartial<I extends {
status?: SE2TrajectoryCommand_Feedback_Status | undefined;
bodyMovementStatus?: SE2TrajectoryCommand_Feedback_BodyMovementStatus | undefined;
} & {
status?: SE2TrajectoryCommand_Feedback_Status | undefined;
bodyMovementStatus?: SE2TrajectoryCommand_Feedback_BodyMovementStatus | undefined;
} & { [K in Exclude<keyof I, keyof SE2TrajectoryCommand_Feedback>]: never; }>(object: I): SE2TrajectoryCommand_Feedback;
};
export declare const SE2VelocityCommand: {
encode(_: SE2VelocityCommand, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): SE2VelocityCommand;
fromJSON(_: any): SE2VelocityCommand;
toJSON(_: SE2VelocityCommand): unknown;
fromPartial<I extends {} & {} & { [K in Exclude<keyof I, never>]: never; }>(_: I): SE2VelocityCommand;
};
export declare const SE2VelocityCommand_Request: {
encode(message: SE2VelocityCommand_Request, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): SE2VelocityCommand_Request;
fromJSON(object: any): SE2VelocityCommand_Request;
toJSON(message: SE2VelocityCommand_Request): unknown;
fromPartial<I extends {
endTime?: Date | undefined;
se2FrameName?: string | undefined;
velocity?: {
linear?: {
x?: number | undefined;
y?: number | undefined;
} | undefined;
angular?: number | undefined;
} | undefined;
slewRateLimit?: {
linear?: {
x?: number | undefined;
y?: number | undefined;
} | undefined;
angular?: number | undefined;
} | undefined;
} & {
endTime?: Date | undefined;
se2FrameName?: string | undefined;
velocity?: ({
linear?: {
x?: number | undefined;
y?: number | undefined;
} | undefined;
angular?: number | undefined;
} & {
linear?: ({
x?: number | undefined;
y?: number | undefined;
} & {
x?: number | undefined;
y?: number | undefined;
} & { [K in Exclude<keyof I["velocity"]["linear"], keyof Vec2>]: never; }) | undefined;
angular?: number | undefined;
} & { [K_1 in Exclude<keyof I["velocity"], keyof SE2Velocity>]: never; }) | undefined;
slewRateLimit?: ({
linear?: {
x?: number | undefined;
y?: number | undefined;
} | undefined;
angular?: number | undefined;
} & {
linear?: ({
x?: number | undefined;
y?: number | undefined;
} & {
x?: number | undefined;
y?: number | undefined;
} & { [K_2 in Exclude<keyof I["slewRateLimit"]["linear"], keyof Vec2>]: never; }) | undefined;
angular?: number | undefined;
} & { [K_3 in Exclude<keyof I["slewRateLimit"], keyof SE2Velocity>]: never; }) | undefined;
} & { [K_4 in Exclude<keyof I, keyof SE2VelocityCommand_Request>]: never; }>(object: I): SE2VelocityCommand_Request;
};
export declare const SE2VelocityCommand_Feedback: {
encode(_: SE2VelocityCommand_Feedback, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): SE2VelocityCommand_Feedback;
fromJSON(_: any): SE2VelocityCommand_Feedback;
toJSON(_: SE2VelocityCommand_Feedback): unknown;
fromPartial<I extends {} & {} & { [K in Exclude<keyof I, never>]: never; }>(_: I): SE2VelocityCommand_Feedback;
};
export declare const SitCommand: {
encode(_: SitCommand, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): SitCommand;
fromJSON(_: any): SitCommand;
toJSON(_: SitCommand): unknown;
fromPartial<I extends {} & {} & { [K in Exclude<keyof I, never>]: never; }>(_: I): SitCommand;
};
export declare const SitCommand_Request: {
encode(_: SitCommand_Request, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): SitCommand_Request;
fromJSON(_: any): SitCommand_Request;
toJSON(_: SitCommand_Request): unknown;
fromPartial<I extends {} & {} & { [K in Exclude<keyof I, never>]: never; }>(_: I): SitCommand_Request;
};
export declare const SitCommand_Feedback: {
encode(message: SitCommand_Feedback, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): SitCommand_Feedback;
fromJSON(object: any): SitCommand_Feedback;
toJSON(message: SitCommand_Feedback): unknown;
fromPartial<I extends {
status?: SitCommand_Feedback_Status | undefined;
} & {
status?: SitCommand_Feedback_Status | undefined;
} & { [K in Exclude<keyof I, "status">]: never; }>(object: I): SitCommand_Feedback;
};
export declare const StandCommand: {
encode(_: StandCommand, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): StandCommand;
fromJSON(_: any): StandCommand;
toJSON(_: StandCommand): unknown;
fromPartial<I extends {} & {} & { [K in Exclude<keyof I, never>]: never; }>(_: I): StandCommand;
};
export declare const StandCommand_Request: {
encode(_: StandCommand_Request, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): StandCommand_Request;
fromJSON(_: any): StandCommand_Request;
toJSON(_: StandCommand_Request): unknown;
fromPartial<I extends {} & {} & { [K in Exclude<keyof I, never>]: never; }>(_: I): StandCommand_Request;
};
export declare const StandCommand_Feedback: {
encode(message: StandCommand_Feedback, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): StandCommand_Feedback;
fromJSON(object: any): StandCommand_Feedback;
toJSON(message: StandCommand_Feedback): unknown;
fromPartial<I extends {
status?: StandCommand_Feedback_Status | undefined;
standingState?: StandCommand_Feedback_StandingState | undefined;
} & {
status?: StandCommand_Feedback_Status | undefined;
standingState?: StandCommand_Feedback_StandingState | undefined;
} & { [K in Exclude<keyof I, keyof StandCommand_Feedback>]: never; }>(object: I): StandCommand_Feedback;
};
export declare const StanceCommand: {
encode(_: StanceCommand, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): StanceCommand;
fromJSON(_: any): StanceCommand;
toJSON(_: StanceCommand): unknown;
fromPartial<I extends {} & {} & { [K in Exclude<keyof I, never>]: never; }>(_: I): StanceCommand;
};
export declare const StanceCommand_Request: {
encode(message: StanceCommand_Request, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): StanceCommand_Request;
fromJSON(object: any): StanceCommand_Request;
toJSON(message: StanceCommand_Request): unknown;
fromPartial<I extends {
endTime?: Date | undefined;
stance?: {
se2FrameName?: string | undefined;
footPositions?: {
[x: string]: {
x?: number | undefined;
y?: number | undefined;
} | undefined;
} | undefined;
accuracy?: number | undefined;
} | undefined;
} & {
endTime?: Date | undefined;
stance?: ({
se2FrameName?: string | undefined;
footPositions?: {
[x: string]: {
x?: number | undefined;
y?: number | undefined;
} | undefined;
} | undefined;
accuracy?: number | undefined;
} & {
se2FrameName?: string | undefined;
footPositions?: ({
[x: string]: {
x?: number | undefined;
y?: number | undefined;
} | undefined;
} & {
[x: string]: ({
x?: number | undefined;
y?: number | undefined;
} & {
x?: number | undefined;
y?: number | undefined;
} & { [K in Exclude<keyof I["stance"]["footPositions"][string], keyof Vec2>]: never; }) | undefined;
} & { [K_1 in Exclude<keyof I["stance"]["footPositions"], string | number>]: never; }) | undefined;
accuracy?: number | undefined;
} & { [K_2 in Exclude<keyof I["stance"], keyof Stance>]: never; }) | undefined;
} & { [K_3 in Exclude<keyof I, keyof StanceCommand_Request>]: never; }>(object: I): StanceCommand_Request;
};
export declare const StanceCommand_Feedback: {
encode(message: StanceCommand_Feedback, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): StanceCommand_Feedback;
fromJSON(object: any): StanceCommand_Feedback;
toJSON(message: StanceCommand_Feedback): unknown;
fromPartial<I extends {
status?: StanceCommand_Feedback_Status | undefined;
} & {
status?: StanceCommand_Feedback_Status | undefined;
} & { [K in Exclude<keyof I, "status">]: never; }>(object: I): StanceCommand_Feedback;
};
export declare const Stance: {
encode(message: Stance, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): Stance;
fromJSON(object: any): Stance;
toJSON(message: Stance): unknown;
fromPartial<I extends {
se2FrameName?: string | undefined;
footPositions?: {
[x: string]: {
x?: number | undefined;
y?: number | undefined;
} | undefined;
} | undefined;
accuracy?: number | undefined;
} & {
se2FrameName?: string | undefined;
footPositions?: ({
[x: string]: {
x?: number | undefined;
y?: number | undefined;
} | undefined;
} & {
[x: string]: ({
x?: number | undefined;