spot-sdk-ts/generated/bosdyn/api/graph_nav/graph_nav.ts

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

/* eslint-disable */
import {
  SE2TrajectoryCommand_Feedback_BodyMovementStatus,
  sE2TrajectoryCommand_Feedback_BodyMovementStatusFromJSON,
  sE2TrajectoryCommand_Feedback_BodyMovementStatusToJSON,
} from "../basic_command";
import {
  LicenseInfo_Status,
  licenseInfo_StatusFromJSON,
  licenseInfo_StatusToJSON,
} from "../license";
import { Timestamp } from "../../../google/protobuf/timestamp";
import { RequestHeader, ResponseHeader } from "../header";
import { Localization, Route } from "./nav";
import { SE3Pose, SE2VelocityLimit, SE2Pose, Vec3 } from "../geometry";
import { LeaseUseResult, Lease } from "../lease";
import { RobotImpairedState, KinematicState } from "../robot_state";
import { Edge_Id, WaypointSnapshot, Graph } from "./map";
import { DataChunk } from "../data_chunk";
import _m0 from "protobufjs/minimal";

export const protobufPackage = "bosdyn.api.graph_nav";

/**
 * The SetLocalization request is used to initialize or reset the localization of GraphNav
 * to a map. A localization consists of a waypoint ID, and a pose of the robot relative to that waypoint.
 * GraphNav uses the localization to decide how to navigate through a map.
 * The SetLocalizationRequest contains parameters to help find a correct localization. For example,
 * AprilTags (fiducials) may be used to set the localization, or the caller can provide an explicit
 * guess of the localization.
 * Once the SetLocalizationRequest completes, the current localization to the map
 * will be modified, and can be retrieved using a GetLocalizationStateRequest.
 */
export interface SetLocalizationRequest {
  /** Common request header. */
  header: RequestHeader | undefined;
  /** Operator-supplied guess at localization. */
  initialGuess: Localization | undefined;
  /**
   * Robot pose when the initial_guess was made.
   * This overcomes the race that occurs when the client is trying to initialize a moving robot.
   * GraphNav will use its local ko_tform_body and this ko_tform_body to update the initial
   * localization guess, if necessary.
   */
  koTformBody: SE3Pose | undefined;
  /**
   * The max distance [meters] is how far away the robot is allowed to localize from the position supplied
   * in the initial guess. If not specified, the offset is used directly. Otherwise it searches a neighborhood
   * of the given size.
   */
  maxDistance: number;
  /**
   * The max yaw [radians] is how different the localized yaw is allowed to be from the supplied yaw
   * in the initial guess. If not specified, the offset is used directly. Otherwise it searches a neighborhood
   * of the given size.
   */
  maxYaw: number;
  /** Tells the initializer whether to use fiducials, and how to use them. */
  fiducialInit: SetLocalizationRequest_FiducialInit;
  /**
   * If using FIDUCIAL_INIT_SPECIFIC, this is the specific fiducial ID to use for initialization.
   * If no detection of this fiducial exists, the service will return STATUS_NO_MATCHING_FIDUCIAL.
   * If detections exist, but are low quality, STATUS_FIDUCIAL_TOO_FAR_AWAY, FIDUCIAL_TOO_OLD, or FIDUCIAL_POSE_UNCERTAIN will be returned.
   */
  useFiducialId: number;
  /**
   * If true, and we are using fiducials during initialization, will run ICP after the fiducial
   * was used for an initial guess.
   */
  refineFiducialResultWithIcp: boolean;
  /** If true, consider how nearby localizations appear (like turned 180). */
  doAmbiguityCheck: boolean;
  /**
   * If using FIDUCIAL_INIT_SPECIFIC and this is true, the initializer will only consider
   * fiducial detections from the target waypoint (from initial_guess). Otherwise, if the
   * target waypoint does not contain a good measurement of the desired fiducial, nearby waypoints
   * may be used to infer the robot's location.
   */
  restrictFiducialDetectionsToTargetWaypoint: boolean;
}

export enum SetLocalizationRequest_FiducialInit {
  /** FIDUCIAL_INIT_UNKNOWN - It is a programming error to use this one. */
  FIDUCIAL_INIT_UNKNOWN = 0,
  /** FIDUCIAL_INIT_NO_FIDUCIAL - Ignore fiducials during initialization. */
  FIDUCIAL_INIT_NO_FIDUCIAL = 1,
  /** FIDUCIAL_INIT_NEAREST - Localize to the nearest fiducial in any waypoint. */
  FIDUCIAL_INIT_NEAREST = 2,
  /** FIDUCIAL_INIT_NEAREST_AT_TARGET - Localize to nearest fiducial at the target waypoint (from initial_guess). */
  FIDUCIAL_INIT_NEAREST_AT_TARGET = 3,
  /** FIDUCIAL_INIT_SPECIFIC - Localize to the given fiducial at the target waypoint (from initial_guess) if it exists, or any waypoint otherwise. */
  FIDUCIAL_INIT_SPECIFIC = 4,
  UNRECOGNIZED = -1,
}

export function setLocalizationRequest_FiducialInitFromJSON(
  object: any
): SetLocalizationRequest_FiducialInit {
  switch (object) {
    case 0:
    case "FIDUCIAL_INIT_UNKNOWN":
      return SetLocalizationRequest_FiducialInit.FIDUCIAL_INIT_UNKNOWN;
    case 1:
    case "FIDUCIAL_INIT_NO_FIDUCIAL":
      return SetLocalizationRequest_FiducialInit.FIDUCIAL_INIT_NO_FIDUCIAL;
    case 2:
    case "FIDUCIAL_INIT_NEAREST":
      return SetLocalizationRequest_FiducialInit.FIDUCIAL_INIT_NEAREST;
    case 3:
    case "FIDUCIAL_INIT_NEAREST_AT_TARGET":
      return SetLocalizationRequest_FiducialInit.FIDUCIAL_INIT_NEAREST_AT_TARGET;
    case 4:
    case "FIDUCIAL_INIT_SPECIFIC":
      return SetLocalizationRequest_FiducialInit.FIDUCIAL_INIT_SPECIFIC;
    case -1:
    case "UNRECOGNIZED":
    default:
      return SetLocalizationRequest_FiducialInit.UNRECOGNIZED;
  }
}

export function setLocalizationRequest_FiducialInitToJSON(
  object: SetLocalizationRequest_FiducialInit
): string {
  switch (object) {
    case SetLocalizationRequest_FiducialInit.FIDUCIAL_INIT_UNKNOWN:
      return "FIDUCIAL_INIT_UNKNOWN";
    case SetLocalizationRequest_FiducialInit.FIDUCIAL_INIT_NO_FIDUCIAL:
      return "FIDUCIAL_INIT_NO_FIDUCIAL";
    case SetLocalizationRequest_FiducialInit.FIDUCIAL_INIT_NEAREST:
      return "FIDUCIAL_INIT_NEAREST";
    case SetLocalizationRequest_FiducialInit.FIDUCIAL_INIT_NEAREST_AT_TARGET:
      return "FIDUCIAL_INIT_NEAREST_AT_TARGET";
    case SetLocalizationRequest_FiducialInit.FIDUCIAL_INIT_SPECIFIC:
      return "FIDUCIAL_INIT_SPECIFIC";
    case SetLocalizationRequest_FiducialInit.UNRECOGNIZED:
    default:
      return "UNRECOGNIZED";
  }
}

/**
 * Info on whether the robot's current sensor setup is compatible with the recorded data
 * in the map.
 */
export interface SensorCompatibilityStatus {
  /** If true, the loaded map has LIDAR data in it. */
  mapHasLidarData: boolean;
  /** If true, the robot is currently configured to use LIDAR data. */
  robotConfiguredForLidar: boolean;
}

/** The SetLocalization response message contains the resulting localization to the map. */
export interface SetLocalizationResponse {
  /** Common response header. */
  header: ResponseHeader | undefined;
  /** Result of using the lease. */
  leaseUseResult: LeaseUseResult | undefined;
  /** Return status for the request. */
  status: SetLocalizationResponse_Status;
  /** If set, describes the reason the status is not OK. */
  errorReport: string;
  /** Result of localization. */
  localization: Localization | undefined;
  /** Alternative information if the localization is ambiguous. */
  suspectedAmbiguity: SetLocalizationResponse_SuspectedAmbiguity | undefined;
  /** If the status is ROBOT_IMPAIRED, this is why the robot is impaired. */
  impairedState: RobotImpairedState | undefined;
  /**
   * This status determines whether the robot has compatible sensors for the
   * map that was recorded. Note that if sensors aren't working, STATUS_IMPARIED
   * will be returned, rather than STATUS_INCOMPATIBLE_SENSORS.
   */
  sensorStatus: SensorCompatibilityStatus | undefined;
}

export enum SetLocalizationResponse_Status {
  /** STATUS_UNKNOWN - The status is unknown/unset. */
  STATUS_UNKNOWN = 0,
  /** STATUS_OK - Localization success. */
  STATUS_OK = 1,
  /** STATUS_ROBOT_IMPAIRED - Robot is experiencing a condition that prevents localization. */
  STATUS_ROBOT_IMPAIRED = 2,
  /**
   * STATUS_UNKNOWN_WAYPOINT - The given waypoint is unknown by the system.
   * This could be due to a client error, or because the graph was changed out from under the
   * client.
   */
  STATUS_UNKNOWN_WAYPOINT = 3,
  /** STATUS_ABORTED - Localization was aborted, likely because of a new request. */
  STATUS_ABORTED = 4,
  /**
   * STATUS_FAILED - Failed to localize for some other reason; see the error_report for details.
   * This is often because the initial guess was incorrect.
   */
  STATUS_FAILED = 5,
  /**
   * STATUS_FIDUCIAL_TOO_FAR_AWAY - Failed to localize because the fiducial requested by 'use_fiducial_id' was too far away from
   * the robot.
   */
  STATUS_FIDUCIAL_TOO_FAR_AWAY = 6,
  /**
   * STATUS_FIDUCIAL_TOO_OLD - Failed to localize because the fiducial requested by 'use_fiducial_id' had a detection time that was too
   * far in the past.
   */
  STATUS_FIDUCIAL_TOO_OLD = 7,
  /**
   * STATUS_NO_MATCHING_FIDUCIAL - Failed to localize because the fiducial requested by 'use_fiducial_id' did not exist in the map at
   * the required location.
   */
  STATUS_NO_MATCHING_FIDUCIAL = 8,
  /**
   * STATUS_FIDUCIAL_POSE_UNCERTAIN - Failed to localize because the fiducial requested by 'use_fiducial_id' had an unreliable
   * pose estimation, either in the current detection of that fiducial, or in detections that
   * were saved in the map. Note that when using FIDUCIAL_INIT_SPECIFIC, fiducial detections at
   * the target waypoint will be used so long as they are not uncertain -- otherwise, detections
   * at adjacent waypoints may be used. If there exists no uncertain detection of the fiducial
   * near the target waypoint in the map, the service returns this status.
   */
  STATUS_FIDUCIAL_POSE_UNCERTAIN = 9,
  /**
   * STATUS_INCOMPATIBLE_SENSORS - The localization could not be set, because the map was recorded using a different sensor
   * setup than the robot currently has onboard. See SensorStatus for more details.
   */
  STATUS_INCOMPATIBLE_SENSORS = 10,
  UNRECOGNIZED = -1,
}

export function setLocalizationResponse_StatusFromJSON(
  object: any
): SetLocalizationResponse_Status {
  switch (object) {
    case 0:
    case "STATUS_UNKNOWN":
      return SetLocalizationResponse_Status.STATUS_UNKNOWN;
    case 1:
    case "STATUS_OK":
      return SetLocalizationResponse_Status.STATUS_OK;
    case 2:
    case "STATUS_ROBOT_IMPAIRED":
      return SetLocalizationResponse_Status.STATUS_ROBOT_IMPAIRED;
    case 3:
    case "STATUS_UNKNOWN_WAYPOINT":
      return SetLocalizationResponse_Status.STATUS_UNKNOWN_WAYPOINT;
    case 4:
    case "STATUS_ABORTED":
      return SetLocalizationResponse_Status.STATUS_ABORTED;
    case 5:
    case "STATUS_FAILED":
      return SetLocalizationResponse_Status.STATUS_FAILED;
    case 6:
    case "STATUS_FIDUCIAL_TOO_FAR_AWAY":
      return SetLocalizationResponse_Status.STATUS_FIDUCIAL_TOO_FAR_AWAY;
    case 7:
    case "STATUS_FIDUCIAL_TOO_OLD":
      return SetLocalizationResponse_Status.STATUS_FIDUCIAL_TOO_OLD;
    case 8:
    case "STATUS_NO_MATCHING_FIDUCIAL":
      return SetLocalizationResponse_Status.STATUS_NO_MATCHING_FIDUCIAL;
    case 9:
    case "STATUS_FIDUCIAL_POSE_UNCERTAIN":
      return SetLocalizationResponse_Status.STATUS_FIDUCIAL_POSE_UNCERTAIN;
    case 10:
    case "STATUS_INCOMPATIBLE_SENSORS":
      return SetLocalizationResponse_Status.STATUS_INCOMPATIBLE_SENSORS;
    case -1:
    case "UNRECOGNIZED":
    default:
      return SetLocalizationResponse_Status.UNRECOGNIZED;
  }
}

export function setLocalizationResponse_StatusToJSON(
  object: SetLocalizationResponse_Status
): string {
  switch (object) {
    case SetLocalizationResponse_Status.STATUS_UNKNOWN:
      return "STATUS_UNKNOWN";
    case SetLocalizationResponse_Status.STATUS_OK:
      return "STATUS_OK";
    case SetLocalizationResponse_Status.STATUS_ROBOT_IMPAIRED:
      return "STATUS_ROBOT_IMPAIRED";
    case SetLocalizationResponse_Status.STATUS_UNKNOWN_WAYPOINT:
      return "STATUS_UNKNOWN_WAYPOINT";
    case SetLocalizationResponse_Status.STATUS_ABORTED:
      return "STATUS_ABORTED";
    case SetLocalizationResponse_Status.STATUS_FAILED:
      return "STATUS_FAILED";
    case SetLocalizationResponse_Status.STATUS_FIDUCIAL_TOO_FAR_AWAY:
      return "STATUS_FIDUCIAL_TOO_FAR_AWAY";
    case SetLocalizationResponse_Status.STATUS_FIDUCIAL_TOO_OLD:
      return "STATUS_FIDUCIAL_TOO_OLD";
    case SetLocalizationResponse_Status.STATUS_NO_MATCHING_FIDUCIAL:
      return "STATUS_NO_MATCHING_FIDUCIAL";
    case SetLocalizationResponse_Status.STATUS_FIDUCIAL_POSE_UNCERTAIN:
      return "STATUS_FIDUCIAL_POSE_UNCERTAIN";
    case SetLocalizationResponse_Status.STATUS_INCOMPATIBLE_SENSORS:
      return "STATUS_INCOMPATIBLE_SENSORS";
    case SetLocalizationResponse_Status.UNRECOGNIZED:
    default:
      return "UNRECOGNIZED";
  }
}

export interface SetLocalizationResponse_SuspectedAmbiguity {
  /**
   * Example of a potentially ambiguous localization near the
   * result of the initialization.
   */
  alternateRobotTformWaypoint: SE3Pose | undefined;
}

export interface RouteGenParams {}

/** Parameters describing how to travel along a route. */
export interface TravelParams {
  /**
   * Threshold for the maximum distance [meters] that defines when we have reached
   * the final waypoint.
   */
  maxDistance: number;
  /**
   * Threshold for the maximum yaw [radians] that defines when we have reached
   * the final waypoint (ignored if ignore_final_yaw is set to true).
   */
  maxYaw: number;
  /**
   * Speed the robot should use.
   * Omit to let the robot choose.
   */
  velocityLimit: SE2VelocityLimit | undefined;
  /**
   * If true, the robot will only try to achieve
   * the final translation of the route. Otherwise,
   * it will attempt to achieve the yaw as well.
   */
  ignoreFinalYaw: boolean;
  featureQualityTolerance: TravelParams_FeatureQualityTolerance;
  /** Disable directed exploration to skip blocked portions of route */
  disableDirectedExploration: boolean;
  /** Disable alternate-route-finding; overrides the per-edge setting in the map. */
  disableAlternateRouteFinding: boolean;
}

/** Indicates whether robot will navigate through areas with poor quality features */
export enum TravelParams_FeatureQualityTolerance {
  /** TOLERANCE_UNKNOWN - Unknown value */
  TOLERANCE_UNKNOWN = 0,
  /** TOLERANCE_DEFAULT - Navigate through default number of waypoints with poor quality features */
  TOLERANCE_DEFAULT = 1,
  /** TOLERANCE_IGNORE_POOR_FEATURE_QUALITY - Navigate through unlimited number of waypoints with poor quality features */
  TOLERANCE_IGNORE_POOR_FEATURE_QUALITY = 2,
  UNRECOGNIZED = -1,
}

export function travelParams_FeatureQualityToleranceFromJSON(
  object: any
): TravelParams_FeatureQualityTolerance {
  switch (object) {
    case 0:
    case "TOLERANCE_UNKNOWN":
      return TravelParams_FeatureQualityTolerance.TOLERANCE_UNKNOWN;
    case 1:
    case "TOLERANCE_DEFAULT":
      return TravelParams_FeatureQualityTolerance.TOLERANCE_DEFAULT;
    case 2:
    case "TOLERANCE_IGNORE_POOR_FEATURE_QUALITY":
      return TravelParams_FeatureQualityTolerance.TOLERANCE_IGNORE_POOR_FEATURE_QUALITY;
    case -1:
    case "UNRECOGNIZED":
    default:
      return TravelParams_FeatureQualityTolerance.UNRECOGNIZED;
  }
}

export function travelParams_FeatureQualityToleranceToJSON(
  object: TravelParams_FeatureQualityTolerance
): string {
  switch (object) {
    case TravelParams_FeatureQualityTolerance.TOLERANCE_UNKNOWN:
      return "TOLERANCE_UNKNOWN";
    case TravelParams_FeatureQualityTolerance.TOLERANCE_DEFAULT:
      return "TOLERANCE_DEFAULT";
    case TravelParams_FeatureQualityTolerance.TOLERANCE_IGNORE_POOR_FEATURE_QUALITY:
      return "TOLERANCE_IGNORE_POOR_FEATURE_QUALITY";
    case TravelParams_FeatureQualityTolerance.UNRECOGNIZED:
    default:
      return "UNRECOGNIZED";
  }
}

/**
 * The NavigateToRequest can be used to command GraphNav to drive the robot to a specific waypoint.
 * GraphNav will plan a path through the map which most efficiently gets the robot to the specified goal waypoint.
 * Parameters are provided which influence how GraphNav will generate and follow the path.
 * This RPC returns immediately after the request is processed. It does not block until GraphNav completes the path
 * to the goal waypoint. The user is expected to periodically check the status of the NavigateTo command using
 * the NavigationFeedbackRequest RPC.
 */
export interface NavigateToRequest {
  /** Common request header. */
  header: RequestHeader | undefined;
  /** The Leases to show ownership of the robot and the graph. */
  leases: Lease[];
  /** ID of the waypoint to go to. */
  destinationWaypointId: string;
  /** Preferences on how to pick the route. */
  routeParams: RouteGenParams | undefined;
  /** Parameters that define how to traverse and end the route. */
  travelParams: TravelParams | undefined;
  /** The timestamp (in robot time) that the navigation command is valid until. */
  endTime: Date | undefined;
  /** Identifier provided by the time sync service to verify time sync between robot and client. */
  clockIdentifier: string;
  /**
   * If provided, graph_nav will move the robot to an SE2 pose relative to the waypoint.
   * Note that the robot will treat this as a simple goto request. It will first arrive at the
   * destination waypoint, and then travel in a straight line from the destination waypoint to the
   * offset goal, attempting to avoid obstacles along the way.
   */
  destinationWaypointTformBodyGoal: SE2Pose | undefined;
  /**
   * Unique identifier for the command. If 0, this is a new command, otherwise it is a continuation
   * of an existing command. If this is a continuation of an existing command, all parameters will be
   * ignored, and the old parameters will be preserved.
   */
  commandId: number;
}

/**
 * Response to a NavigateToRequest. This is returned immediately after the request is processed. A command_id
 * is provided to specify the ID that the user may use to poll the system for feedback on the NavigateTo command.
 */
export interface NavigateToResponse {
  /** Common response header. */
  header: ResponseHeader | undefined;
  /** Results of using the various leases. */
  leaseUseResults: LeaseUseResult[];
  /** Return status for the request. */
  status: NavigateToResponse_Status;
  /** If the status is ROBOT_IMPAIRED, this is why the robot is impaired. */
  impairedState: RobotImpairedState | undefined;
  /** Unique identifier for the command, If 0, command was not accepted. */
  commandId: number;
  /** On a relevant error status code, these fields contain the waypoint/edge IDs that caused the error. */
  errorWaypointIds: string[];
}

export enum NavigateToResponse_Status {
  /** STATUS_UNKNOWN - An unknown / unexpected error occurred. */
  STATUS_UNKNOWN = 0,
  /** STATUS_OK - Request was accepted. */
  STATUS_OK = 1,
  /** STATUS_NO_TIMESYNC - [Time error] Client has not done timesync with robot. */
  STATUS_NO_TIMESYNC = 2,
  /** STATUS_EXPIRED - [Time error] The command was received after its end time had already passed. */
  STATUS_EXPIRED = 3,
  /** STATUS_TOO_DISTANT - [Time error]The command end time was too far in the future. */
  STATUS_TOO_DISTANT = 4,
  /**
   * STATUS_ROBOT_IMPAIRED - [Robot State Error] Cannot navigate a route if the robot has a critical
   *  perception fault, or behavior fault, or LIDAR not working.
   */
  STATUS_ROBOT_IMPAIRED = 5,
  /** STATUS_RECORDING - [Robot State Error] Cannot navigate a route while recording a map. */
  STATUS_RECORDING = 6,
  /** STATUS_UNKNOWN_WAYPOINT - [Route Error] One or more of the waypoints specified weren't in the map. */
  STATUS_UNKNOWN_WAYPOINT = 7,
  /** STATUS_NO_PATH - [Route Error] There is no path to the specified waypoint. */
  STATUS_NO_PATH = 8,
  /** STATUS_FEATURE_DESERT - [Route Error] Route contained too many waypoints with low-quality features. */
  STATUS_FEATURE_DESERT = 10,
  /** STATUS_LOST - [Route Error] Happens when you try to issue a navigate to while the robot is lost. */
  STATUS_LOST = 11,
  /** STATUS_NOT_LOCALIZED_TO_MAP - [Route Error] Happens when the current localization doesn't refer to any waypoint in the map (possibly uninitialized localization). */
  STATUS_NOT_LOCALIZED_TO_MAP = 13,
  /** STATUS_COULD_NOT_UPDATE_ROUTE - [Wrestling error] Happens when graph nav refuses to follow the route you specified. */
  STATUS_COULD_NOT_UPDATE_ROUTE = 12,
  /**
   * STATUS_STUCK - [Route Error] Happens when you try to issue a navigate to while the robot is stuck. Navigate to a different
   * waypoint, or clear the route and try again.
   */
  STATUS_STUCK = 14,
  /** STATUS_UNRECOGNIZED_COMMAND - [Request Error] Happens when you try to continue a command that was either expired, or had an unrecognized id. */
  STATUS_UNRECOGNIZED_COMMAND = 15,
  UNRECOGNIZED = -1,
}

export function navigateToResponse_StatusFromJSON(
  object: any
): NavigateToResponse_Status {
  switch (object) {
    case 0:
    case "STATUS_UNKNOWN":
      return NavigateToResponse_Status.STATUS_UNKNOWN;
    case 1:
    case "STATUS_OK":
      return NavigateToResponse_Status.STATUS_OK;
    case 2:
    case "STATUS_NO_TIMESYNC":
      return NavigateToResponse_Status.STATUS_NO_TIMESYNC;
    case 3:
    case "STATUS_EXPIRED":
      return NavigateToResponse_Status.STATUS_EXPIRED;
    case 4:
    case "STATUS_TOO_DISTANT":
      return NavigateToResponse_Status.STATUS_TOO_DISTANT;
    case 5:
    case "STATUS_ROBOT_IMPAIRED":
      return NavigateToResponse_Status.STATUS_ROBOT_IMPAIRED;
    case 6:
    case "STATUS_RECORDING":
      return NavigateToResponse_Status.STATUS_RECORDING;
    case 7:
    case "STATUS_UNKNOWN_WAYPOINT":
      return NavigateToResponse_Status.STATUS_UNKNOWN_WAYPOINT;
    case 8:
    case "STATUS_NO_PATH":
      return NavigateToResponse_Status.STATUS_NO_PATH;
    case 10:
    case "STATUS_FEATURE_DESERT":
      return NavigateToResponse_Status.STATUS_FEATURE_DESERT;
    case 11:
    case "STATUS_LOST":
      return NavigateToResponse_Status.STATUS_LOST;
    case 13:
    case "STATUS_NOT_LOCALIZED_TO_MAP":
      return NavigateToResponse_Status.STATUS_NOT_LOCALIZED_TO_MAP;
    case 12:
    case "STATUS_COULD_NOT_UPDATE_ROUTE":
      return NavigateToResponse_Status.STATUS_COULD_NOT_UPDATE_ROUTE;
    case 14:
    case "STATUS_STUCK":
      return NavigateToResponse_Status.STATUS_STUCK;
    case 15:
    case "STATUS_UNRECOGNIZED_COMMAND":
      return NavigateToResponse_Status.STATUS_UNRECOGNIZED_COMMAND;
    case -1:
    case "UNRECOGNIZED":
    default:
      return NavigateToResponse_Status.UNRECOGNIZED;
  }
}

export function navigateToResponse_StatusToJSON(
  object: NavigateToResponse_Status
): string {
  switch (object) {
    case NavigateToResponse_Status.STATUS_UNKNOWN:
      return "STATUS_UNKNOWN";
    case NavigateToResponse_Status.STATUS_OK:
      return "STATUS_OK";
    case NavigateToResponse_Status.STATUS_NO_TIMESYNC:
      return "STATUS_NO_TIMESYNC";
    case NavigateToResponse_Status.STATUS_EXPIRED:
      return "STATUS_EXPIRED";
    case NavigateToResponse_Status.STATUS_TOO_DISTANT:
      return "STATUS_TOO_DISTANT";
    case NavigateToResponse_Status.STATUS_ROBOT_IMPAIRED:
      return "STATUS_ROBOT_IMPAIRED";
    case NavigateToResponse_Status.STATUS_RECORDING:
      return "STATUS_RECORDING";
    case NavigateToResponse_Status.STATUS_UNKNOWN_WAYPOINT:
      return "STATUS_UNKNOWN_WAYPOINT";
    case NavigateToResponse_Status.STATUS_NO_PATH:
      return "STATUS_NO_PATH";
    case NavigateToResponse_Status.STATUS_FEATURE_DESERT:
      return "STATUS_FEATURE_DESERT";
    case NavigateToResponse_Status.STATUS_LOST:
      return "STATUS_LOST";
    case NavigateToResponse_Status.STATUS_NOT_LOCALIZED_TO_MAP:
      return "STATUS_NOT_LOCALIZED_TO_MAP";
    case NavigateToResponse_Status.STATUS_COULD_NOT_UPDATE_ROUTE:
      return "STATUS_COULD_NOT_UPDATE_ROUTE";
    case NavigateToResponse_Status.STATUS_STUCK:
      return "STATUS_STUCK";
    case NavigateToResponse_Status.STATUS_UNRECOGNIZED_COMMAND:
      return "STATUS_UNRECOGNIZED_COMMAND";
    case NavigateToResponse_Status.UNRECOGNIZED:
    default:
      return "UNRECOGNIZED";
  }
}

/** These parameters are specific to how the robot follows a specified route in NavigateRoute. */
export interface RouteFollowingParams {
  newCmdBehavior: RouteFollowingParams_StartRouteBehavior;
  existingCmdBehavior: RouteFollowingParams_ResumeBehavior;
  routeBlockedBehavior: RouteFollowingParams_RouteBlockedBehavior;
}

/**
 * This setting applies when a new NavigateRoute command is issued (different route or
 * final-waypoint-offset), and command_id indicates a new command.
 */
export enum RouteFollowingParams_StartRouteBehavior {
  /** START_UNKNOWN - The mode is unset. */
  START_UNKNOWN = 0,
  /**
   * START_GOTO_START - The robot will find the shortest path to the start of the route, possibly using
   * edges that are not in the route. After going to the start, the robot will follow the
   * route.
   */
  START_GOTO_START = 1,
  /**
   * START_GOTO_ROUTE - The robot will find the shortest path to any point on the route, and go to the point
   * that gives that shortest path. Then, the robot will follow the rest of the route from
   * that point.
   * If multiple points on the route are similarly close to the robot, the robot will
   * prefer the earliest on the route.
   * This is the default.
   */
  START_GOTO_ROUTE = 2,
  /** START_FAIL_WHEN_NOT_ON_ROUTE - The robot will fail the command with status STATUS_NOT_LOCALIZED_TO_ROUTE. */
  START_FAIL_WHEN_NOT_ON_ROUTE = 3,
  UNRECOGNIZED = -1,
}

export function routeFollowingParams_StartRouteBehaviorFromJSON(
  object: any
): RouteFollowingParams_StartRouteBehavior {
  switch (object) {
    case 0:
    case "START_UNKNOWN":
      return RouteFollowingParams_StartRouteBehavior.START_UNKNOWN;
    case 1:
    case "START_GOTO_START":
      return RouteFollowingParams_StartRouteBehavior.START_GOTO_START;
    case 2:
    case "START_GOTO_ROUTE":
      return RouteFollowingParams_StartRouteBehavior.START_GOTO_ROUTE;
    case 3:
    case "START_FAIL_WHEN_NOT_ON_ROUTE":
      return RouteFollowingParams_StartRouteBehavior.START_FAIL_WHEN_NOT_ON_ROUTE;
    case -1:
    case "UNRECOGNIZED":
    default:
      return RouteFollowingParams_StartRouteBehavior.UNRECOGNIZED;
  }
}

export function routeFollowingParams_StartRouteBehaviorToJSON(
  object: RouteFollowingParams_StartRouteBehavior
): string {
  switch (object) {
    case RouteFollowingParams_StartRouteBehavior.START_UNKNOWN:
      return "START_UNKNOWN";
    case RouteFollowingParams_StartRouteBehavior.START_GOTO_START:
      return "START_GOTO_START";
    case RouteFollowingParams_StartRouteBehavior.START_GOTO_ROUTE:
      return "START_GOTO_ROUTE";
    case RouteFollowingParams_StartRouteBehavior.START_FAIL_WHEN_NOT_ON_ROUTE:
      return "START_FAIL_WHEN_NOT_ON_ROUTE";
    case RouteFollowingParams_StartRouteBehavior.UNRECOGNIZED:
    default:
      return "UNRECOGNIZED";
  }
}

/**
 * This setting applies when a NavigateRoute command is issued with the same route and
 * final-waypoint-offset. It is not necessary that command_id indicate the same command.
 * The expected waypoint is the last waypoint that GraphNav was autonomously navigating to.
 */
export enum RouteFollowingParams_ResumeBehavior {
  /** RESUME_UNKNOWN - The mode is unset. */
  RESUME_UNKNOWN = 0,
  /**
   * RESUME_RETURN_TO_UNFINISHED_ROUTE - The robot will find the shortest path to any point on the route after the
   * furthest-along traversed edge, and go to the point that gives that shortest path.
   * Then, the robot will follow the rest of the route from that point.
   * This is the default.
   */
  RESUME_RETURN_TO_UNFINISHED_ROUTE = 1,
  /** RESUME_FAIL_WHEN_NOT_ON_ROUTE - The robot will fail the command with status STATUS_NOT_LOCALIZED_TO_ROUTE. */
  RESUME_FAIL_WHEN_NOT_ON_ROUTE = 2,
  UNRECOGNIZED = -1,
}

export function routeFollowingParams_ResumeBehaviorFromJSON(
  object: any
): RouteFollowingParams_ResumeBehavior {
  switch (object) {
    case 0:
    case "RESUME_UNKNOWN":
      return RouteFollowingParams_ResumeBehavior.RESUME_UNKNOWN;
    case 1:
    case "RESUME_RETURN_TO_UNFINISHED_ROUTE":
      return RouteFollowingParams_ResumeBehavior.RESUME_RETURN_TO_UNFINISHED_ROUTE;
    case 2:
    case "RESUME_FAIL_WHEN_NOT_ON_ROUTE":
      return RouteFollowingParams_ResumeBehavior.RESUME_FAIL_WHEN_NOT_ON_ROUTE;
    case -1:
    case "UNRECOGNIZED":
    default:
      return RouteFollowingParams_ResumeBehavior.UNRECOGNIZED;
  }
}

export function routeFollowingParams_ResumeBehaviorToJSON(
  object: RouteFollowingParams_ResumeBehavior
): string {
  switch (object) {
    case RouteFollowingParams_ResumeBehavior.RESUME_UNKNOWN:
      return "RESUME_UNKNOWN";
    case RouteFollowingParams_ResumeBehavior.RESUME_RETURN_TO_UNFINISHED_ROUTE:
      return "RESUME_RETURN_TO_UNFINISHED_ROUTE";
    case RouteFollowingParams_ResumeBehavior.RESUME_FAIL_WHEN_NOT_ON_ROUTE:
      return "RESUME_FAIL_WHEN_NOT_ON_ROUTE";
    case RouteFollowingParams_ResumeBehavior.UNRECOGNIZED:
    default:
      return "UNRECOGNIZED";
  }
}

/** This setting applies when the robot discovers that the route is blocked. */
export enum RouteFollowingParams_RouteBlockedBehavior {
  /** ROUTE_BLOCKED_UNKNOWN - The mode is unset. */
  ROUTE_BLOCKED_UNKNOWN = 0,
  /**
   * ROUTE_BLOCKED_REROUTE - The robot will find the shortest path to any point after the furthest-along blockage,
   * and after the furthest-along traversed edge, and go to the point that gives that
   * shortest path. Then, the robot will follow the rest of the route from that point.
   * If multiple points on the route are similarly close to the robot, the robot will
   * prefer the earliest on the route.
   * This is the default.
   */
  ROUTE_BLOCKED_REROUTE = 1,
  /** ROUTE_BLOCKED_FAIL - The robot will fail the command with status STATUS_STUCK; */
  ROUTE_BLOCKED_FAIL = 2,
  UNRECOGNIZED = -1,
}

export function routeFollowingParams_RouteBlockedBehaviorFromJSON(
  object: any
): RouteFollowingParams_RouteBlockedBehavior {
  switch (object) {
    case 0:
    case "ROUTE_BLOCKED_UNKNOWN":
      return RouteFollowingParams_RouteBlockedBehavior.ROUTE_BLOCKED_UNKNOWN;
    case 1:
    case "ROUTE_BLOCKED_REROUTE":
      return RouteFollowingParams_RouteBlockedBehavior.ROUTE_BLOCKED_REROUTE;
    case 2:
    case "ROUTE_BLOCKED_FAIL":
      return RouteFollowingParams_RouteBlockedBehavior.ROUTE_BLOCKED_FAIL;
    case -1:
    case "UNRECOGNIZED":
    default:
      return RouteFollowingParams_RouteBlockedBehavior.UNRECOGNIZED;
  }
}

export function routeFollowingParams_RouteBlockedBehaviorToJSON(
  object: RouteFollowingParams_RouteBlockedBehavior
): string {
  switch (object) {
    case RouteFollowingParams_RouteBlockedBehavior.ROUTE_BLOCKED_UNKNOWN:
      return "ROUTE_BLOCKED_UNKNOWN";
    case RouteFollowingParams_RouteBlockedBehavior.ROUTE_BLOCKED_REROUTE:
      return "ROUTE_BLOCKED_REROUTE";
    case RouteFollowingParams_RouteBlockedBehavior.ROUTE_BLOCKED_FAIL:
      return "ROUTE_BLOCKED_FAIL";
    case RouteFollowingParams_RouteBlockedBehavior.UNRECOGNIZED:
    default:
      return "UNRECOGNIZED";
  }
}

/**
 * A NavigateRoute request message specifies a route of waypoints/edges and parameters
 * about how to get there. Like NavigateTo, this command returns immediately upon
 * processing and provides a command_id that the user can use along with a NavigationFeedbackRequest RPC to
 * poll the system for feedback on this command. The RPC does not block until the route is completed.
 */
export interface NavigateRouteRequest {
  /** Common request header. */
  header: RequestHeader | undefined;
  /** The Lease to show ownership of the robot. */
  leases: Lease[];
  /** A route for the robot to follow. */
  route: Route | undefined;
  /**
   * What should the robot do if it is not at the expected point in the route, or the route is
   * blocked.
   */
  routeFollowParams: RouteFollowingParams | undefined;
  /** How to travel the route. */
  travelParams: TravelParams | undefined;
  /** The timestamp (in robot time) that the navigation command is valid until. */
  endTime: Date | undefined;
  /** Identifier provided by the time sync service to verify time sync between robot and client. */
  clockIdentifier: string;
  /**
   * If provided, graph_nav will move the robot to an SE2 pose relative to the final waypoint
   * in the route.
   * Note that the robot will treat this as a simple goto request. It will first arrive at the
   * destination waypoint, and then travel in a straight line from the destination waypoint to the
   * offset goal, attempting to avoid obstacles along the way.
   */
  destinationWaypointTformBodyGoal: SE2Pose | undefined;
  /**
   * Unique identifier for the command. If 0, this is a new command, otherwise it is a continuation
   * of an existing command.
   */
  commandId: number;
}

/**
 * Response to a NavigateRouteRequest. This is returned immediately after the request is processed. A command_id
 * is provided to specify the ID that the user may use to poll the system for feedback on the NavigateRoute command.
 */
export interface NavigateRouteResponse {
  /** Common response header. */
  header: ResponseHeader | undefined;
  /** Details about how the lease was used. */
  leaseUseResults: LeaseUseResult[];
  /** Return status for the request. */
  status: NavigateRouteResponse_Status;
  /** If the status is ROBOT_IMPAIRED, this is why the robot is impaired. */
  impairedState: RobotImpairedState | undefined;
  /** Unique identifier for the command, If 0, command was not accepted. */
  commandId: number;
  /** On a relevant error status code, these fields contain the waypoint/edge IDs that caused the error. */
  errorWaypointIds: string[];
  /** On a relevant error status code (STATUS_INVALID_EDGE), this is populated with the edge ID's that cased the error. */
  errorEdgeIds: Edge_Id[];
}

export enum NavigateRouteResponse_Status {
  /** STATUS_UNKNOWN - An unknown / unexpected error occurred. */
  STATUS_UNKNOWN = 0,
  /** STATUS_OK - Request was accepted. */
  STATUS_OK = 1,
  /** STATUS_NO_TIMESYNC - [Time Error] Client has not done timesync with robot. */
  STATUS_NO_TIMESYNC = 2,
  /** STATUS_EXPIRED - [Time Error] The command was received after its end time had already passed. */
  STATUS_EXPIRED = 3,
  /** STATUS_TOO_DISTANT - [Time Error] The command end time was too far in the future. */
  STATUS_TOO_DISTANT = 4,
  /**
   * STATUS_ROBOT_IMPAIRED - [Robot State Error] Cannot navigate a route if the robot has a crtical
   *  perception fault, or behavior fault, or LIDAR not working.
   */
  STATUS_ROBOT_IMPAIRED = 5,
  /** STATUS_RECORDING - [Robot State Error] Cannot navigate a route while recording a map. */
  STATUS_RECORDING = 6,
  /** STATUS_UNKNOWN_ROUTE_ELEMENTS - [Route Error] One or more waypoints/edges are not in the map. */
  STATUS_UNKNOWN_ROUTE_ELEMENTS = 8,
  /** STATUS_INVALID_EDGE - [Route Error] One or more edges do not connect to expected waypoints. */
  STATUS_INVALID_EDGE = 9,
  /** STATUS_NO_PATH - [Route Error] There is no path to the specified route. */
  STATUS_NO_PATH = 20,
  /** STATUS_CONSTRAINT_FAULT - [Route Error] Route contained a constraint fault. */
  STATUS_CONSTRAINT_FAULT = 11,
  /** STATUS_FEATURE_DESERT - [Route Error] Route contained too many waypoints with low-quality features. */
  STATUS_FEATURE_DESERT = 13,
  /** STATUS_LOST - [Route Error] Happens when you try to issue a navigate route while the robot is lost. */
  STATUS_LOST = 14,
  /**
   * STATUS_NOT_LOCALIZED_TO_ROUTE - [Route Error] Happens when the current localization doesn't refer to any waypoint
   * in the route (possibly uninitialized localization).
   */
  STATUS_NOT_LOCALIZED_TO_ROUTE = 16,
  /** STATUS_NOT_LOCALIZED_TO_MAP - [Route Error] Happens when the current localization doesn't refer to any waypoint in the map (possibly uninitialized localization). */
  STATUS_NOT_LOCALIZED_TO_MAP = 19,
  /** STATUS_COULD_NOT_UPDATE_ROUTE - [Wrestling Errors] Happens when graph nav refuses to follow the route you specified.  Try saying please? */
  STATUS_COULD_NOT_UPDATE_ROUTE = 15,
  /**
   * STATUS_STUCK - [Route Error] Happens when you try to issue a navigate to while the robot is stuck. Navigate a different
   * route, or clear the route and try again.
   */
  STATUS_STUCK = 17,
  /** STATUS_UNRECOGNIZED_COMMAND - [Request Error] Happens when you try to continue a command that was either expired, or had an unrecognized id. */
  STATUS_UNRECOGNIZED_COMMAND = 18,
  UNRECOGNIZED = -1,
}

export function navigateRouteResponse_StatusFromJSON(
  object: any
): NavigateRouteResponse_Status {
  switch (object) {
    case 0:
    case "STATUS_UNKNOWN":
      return NavigateRouteResponse_Status.STATUS_UNKNOWN;
    case 1:
    case "STATUS_OK":
      return NavigateRouteResponse_Status.STATUS_OK;
    case 2:
    case "STATUS_NO_TIMESYNC":
      return NavigateRouteResponse_Status.STATUS_NO_TIMESYNC;
    case 3:
    case "STATUS_EXPIRED":
      return NavigateRouteResponse_Status.STATUS_EXPIRED;
    case 4:
    case "STATUS_TOO_DISTANT":
      return NavigateRouteResponse_Status.STATUS_TOO_DISTANT;
    case 5:
    case "STATUS_ROBOT_IMPAIRED":
      return NavigateRouteResponse_Status.STATUS_ROBOT_IMPAIRED;
    case 6:
    case "STATUS_RECORDING":
      return NavigateRouteResponse_Status.STATUS_RECORDING;
    case 8:
    case "STATUS_UNKNOWN_ROUTE_ELEMENTS":
      return NavigateRouteResponse_Status.STATUS_UNKNOWN_ROUTE_ELEMENTS;
    case 9:
    case "STATUS_INVALID_EDGE":
      return NavigateRouteResponse_Status.STATUS_INVALID_EDGE;
    case 20:
    case "STATUS_NO_PATH":
      return NavigateRouteResponse_Status.STATUS_NO_PATH;
    case 11:
    case "STATUS_CONSTRAINT_FAULT":
      return NavigateRouteResponse_Status.STATUS_CONSTRAINT_FAULT;
    case 13:
    case "STATUS_FEATURE_DESERT":
      return NavigateRouteResponse_Status.STATUS_FEATURE_DESERT;
    case 14:
    case "STATUS_LOST":
      return NavigateRouteResponse_Status.STATUS_LOST;
    case 16:
    case "STATUS_NOT_LOCALIZED_TO_ROUTE":
      return NavigateRouteResponse_Status.STATUS_NOT_LOCALIZED_TO_ROUTE;
    case 19:
    case "STATUS_NOT_LOCALIZED_TO_MAP":
      return NavigateRouteResponse_Status.STATUS_NOT_LOCALIZED_TO_MAP;
    case 15:
    case "STATUS_COULD_NOT_UPDATE_ROUTE":
      return NavigateRouteResponse_Status.STATUS_COULD_NOT_UPDATE_ROUTE;
    case 17:
    case "STATUS_STUCK":
      return NavigateRouteResponse_Status.STATUS_STUCK;
    case 18:
    case "STATUS_UNRECOGNIZED_COMMAND":
      return NavigateRouteResponse_Status.STATUS_UNRECOGNIZED_COMMAND;
    case -1:
    case "UNRECOGNIZED":
    default:
      return NavigateRouteResponse_Status.UNRECOGNIZED;
  }
}

export function navigateRouteResponse_StatusToJSON(
  object: NavigateRouteResponse_Status
): string {
  switch (object) {
    case NavigateRouteResponse_Status.STATUS_UNKNOWN:
      return "STATUS_UNKNOWN";
    case NavigateRouteResponse_Status.STATUS_OK:
      return "STATUS_OK";
    case NavigateRouteResponse_Status.STATUS_NO_TIMESYNC:
      return "STATUS_NO_TIMESYNC";
    case NavigateRouteResponse_Status.STATUS_EXPIRED:
      return "STATUS_EXPIRED";
    case NavigateRouteResponse_Status.STATUS_TOO_DISTANT:
      return "STATUS_TOO_DISTANT";
    case NavigateRouteResponse_Status.STATUS_ROBOT_IMPAIRED:
      return "STATUS_ROBOT_IMPAIRED";
    case NavigateRouteResponse_Status.STATUS_RECORDING:
      return "STATUS_RECORDING";
    case NavigateRouteResponse_Status.STATUS_UNKNOWN_ROUTE_ELEMENTS:
      return "STATUS_UNKNOWN_ROUTE_ELEMENTS";
    case NavigateRouteResponse_Status.STATUS_INVALID_EDGE:
      return "STATUS_INVALID_EDGE";
    case NavigateRouteResponse_Status.STATUS_NO_PATH:
      return "STATUS_NO_PATH";
    case NavigateRouteResponse_Status.STATUS_CONSTRAINT_FAULT:
      return "STATUS_CONSTRAINT_FAULT";
    case NavigateRouteResponse_Status.STATUS_FEATURE_DESERT:
      return "STATUS_FEATURE_DESERT";
    case NavigateRouteResponse_Status.STATUS_LOST:
      return "STATUS_LOST";
    case NavigateRouteResponse_Status.STATUS_NOT_LOCALIZED_TO_ROUTE:
      return "STATUS_NOT_LOCALIZED_TO_ROUTE";
    case NavigateRouteResponse_Status.STATUS_NOT_LOCALIZED_TO_MAP:
      return "STATUS_NOT_LOCALIZED_TO_MAP";
    case NavigateRouteResponse_Status.STATUS_COULD_NOT_UPDATE_ROUTE:
      return "STATUS_COULD_NOT_UPDATE_ROUTE";
    case NavigateRouteResponse_Status.STATUS_STUCK:
      return "STATUS_STUCK";
    case NavigateRouteResponse_Status.STATUS_UNRECOGNIZED_COMMAND:
      return "STATUS_UNRECOGNIZED_COMMAND";
    case NavigateRouteResponse_Status.UNRECOGNIZED:
    default:
      return "UNRECOGNIZED";
  }
}

/**
 * The NavigateToAnchorRequest can be used to command GraphNav to drive the robot to a specific
 * place in an anchoring. GraphNav will find the waypoint that has the shortest path length from
 * robot's current position but is still close to the goal. GraphNav will plan a path through the
 * map which most efficiently gets the robot to the goal waypoint, and will then travel
 * in a straight line from the destination waypoint to the offset goal, attempting to avoid
 * obstacles along the way.
 * Parameters are provided which influence how GraphNav will generate and follow the path.
 * This RPC returns immediately after the request is processed. It does not block until GraphNav
 * completes the path to the goal waypoint. The user is expected to periodically check the status
 * of the NavigateToAnchor command using the NavigationFeedbackRequest RPC.
 */
export interface NavigateToAnchorRequest {
  /** Common request header. */
  header: RequestHeader | undefined;
  /** The Leases to show ownership of the robot and the graph. */
  leases: Lease[];
  /**
   * The goal, expressed with respect to the seed frame of the current anchoring.
   * The robot will use the z value to find the goal waypoint, but the final z height the robot
   * achieves will depend on the terrain height at the offset from the goal.
   */
  seedTformGoal: SE3Pose | undefined;
  /**
   * These parameters control selection of the goal waypoint. In seed frame, they are the x, y,
   * and z tolerances with respect to the goal pose within which waypoints will be considered.
   * If these values are negative, or too small, reasonable defaults will be used.
   */
  goalWaypointRtSeedEwrtSeedTolerance: Vec3 | undefined;
  /** Preferences on how to pick the route. */
  routeParams: RouteGenParams | undefined;
  /** Parameters that define how to traverse and end the route. */
  travelParams: TravelParams | undefined;
  /** The timestamp (in robot time) that the navigation command is valid until. */
  endTime: Date | undefined;
  /** Identifier provided by the time sync service to verify time sync between robot and client. */
  clockIdentifier: string;
  /**
   * Unique identifier for the command. If 0, this is a new command, otherwise it is a continuation
   * of an existing command. If this is a continuation of an existing command, all parameters will be
   * ignored, and the old parameters will be preserved.
   */
  commandId: number;
}

/**
 * Response to a NavigateToAnchorRequest. This is returned immediately after the request is
 * processed. A command_id is provided to specify the ID that the user may use to poll the system
 * for feedback on the NavigateTo command.
 */
export interface NavigateToAnchorResponse {
  /** Common response header. */
  header: ResponseHeader | undefined;
  /** Results of using the various leases. */
  leaseUseResults: LeaseUseResult[];
  /** Return status for the request. */
  status: NavigateToAnchorResponse_Status;
  /** If the status is ROBOT_IMPAIRED, this is why the robot is impaired. */
  impairedState: RobotImpairedState | undefined;
  /** Unique identifier for the command, If 0, command was not accepted. */
  commandId: number;
  /** On a relevant error status code, these fields contain the waypoint/edge IDs that caused the error. */
  errorWaypointIds: string[];
}

export enum NavigateToAnchorResponse_Status {
  /** STATUS_UNKNOWN - An unknown / unexpected error occurred. */
  STATUS_UNKNOWN = 0,
  /** STATUS_OK - Request was accepted. */
  STATUS_OK = 1,
  /** STATUS_NO_TIMESYNC - [Time error] Client has not done timesync with robot. */
  STATUS_NO_TIMESYNC = 2,
  /** STATUS_EXPIRED - [Time error] The command was received after its end time had already passed. */
  STATUS_EXPIRED = 3,
  /** STATUS_TOO_DISTANT - [Time error]The command end time was too far in the future. */
  STATUS_TOO_DISTANT = 4,
  /**
   * STATUS_ROBOT_IMPAIRED - [Robot State Error] Cannot navigate a route if the robot has a critical
   *  perception fault, or behavior fault, or LIDAR not working.
   */
  STATUS_ROBOT_IMPAIRED = 5,
  /** STATUS_RECORDING - [Robot State Error] Cannot navigate a route while recording a map. */
  STATUS_RECORDING = 6,
  /** STATUS_NO_ANCHORING - [Route Error] There is no anchoring. */
  STATUS_NO_ANCHORING = 7,
  /**
   * STATUS_NO_PATH - [Route Error] There is no path to a waypoint near the specified goal.
   *               If any waypoints were found (but no path), the error_waypoint_ids field
   *               will be filled.
   */
  STATUS_NO_PATH = 8,
  /** STATUS_FEATURE_DESERT - [Route Error] Route contained too many waypoints with low-quality features. */
  STATUS_FEATURE_DESERT = 10,
  /** STATUS_LOST - [Route Error] Happens when you try to issue a navigate to while the robot is lost. */
  STATUS_LOST = 11,
  /** STATUS_NOT_LOCALIZED_TO_MAP - [Route Error] Happens when the current localization doesn't refer to any waypoint in the map (possibly uninitialized localization). */
  STATUS_NOT_LOCALIZED_TO_MAP = 13,
  /** STATUS_COULD_NOT_UPDATE_ROUTE - [Wrestling error] Happens when graph nav refuses to follow the route you specified. */
  STATUS_COULD_NOT_UPDATE_ROUTE = 12,
  /**
   * STATUS_STUCK - [Route Error] Happens when you try to issue a navigate to while the robot is stuck. Navigate to a different
   * waypoint, or clear the route and try again.
   */
  STATUS_STUCK = 14,
  /** STATUS_UNRECOGNIZED_COMMAND - [Request Error] Happens when you try to continue a command that was either expired, or had an unrecognized id. */
  STATUS_UNRECOGNIZED_COMMAND = 15,
  /** STATUS_INVALID_POSE - [Route Error] The pose is invalid, or known to be unachievable (upside-down, etc). */
  STATUS_INVALID_POSE = 16,
  UNRECOGNIZED = -1,
}

export function navigateToAnchorResponse_StatusFromJSON(
  object: any
): NavigateToAnchorResponse_Status {
  switch (object) {
    case 0:
    case "STATUS_UNKNOWN":
      return NavigateToAnchorResponse_Status.STATUS_UNKNOWN;
    case 1:
    case "STATUS_OK":
      return NavigateToAnchorResponse_Status.STATUS_OK;
    case 2:
    case "STATUS_NO_TIMESYNC":
      return NavigateToAnchorResponse_Status.STATUS_NO_TIMESYNC;
    case 3:
    case "STATUS_EXPIRED":
      return NavigateToAnchorResponse_Status.STATUS_EXPIRED;
    case 4:
    case "STATUS_TOO_DISTANT":
      return NavigateToAnchorResponse_Status.STATUS_TOO_DISTANT;
    case 5:
    case "STATUS_ROBOT_IMPAIRED":
      return NavigateToAnchorResponse_Status.STATUS_ROBOT_IMPAIRED;
    case 6:
    case "STATUS_RECORDING":
      return NavigateToAnchorResponse_Status.STATUS_RECORDING;
    case 7:
    case "STATUS_NO_ANCHORING":
      return NavigateToAnchorResponse_Status.STATUS_NO_ANCHORING;
    case 8:
    case "STATUS_NO_PATH":
      return NavigateToAnchorResponse_Status.STATUS_NO_PATH;
    case 10:
    case "STATUS_FEATURE_DESERT":
      return NavigateToAnchorResponse_Status.STATUS_FEATURE_DESERT;
    case 11:
    case "STATUS_LOST":
      return NavigateToAnchorResponse_Status.STATUS_LOST;
    case 13:
    case "STATUS_NOT_LOCALIZED_TO_MAP":
      return NavigateToAnchorResponse_Status.STATUS_NOT_LOCALIZED_TO_MAP;
    case 12:
    case "STATUS_COULD_NOT_UPDATE_ROUTE":
      return NavigateToAnchorResponse_Status.STATUS_COULD_NOT_UPDATE_ROUTE;
    case 14:
    case "STATUS_STUCK":
      return NavigateToAnchorResponse_Status.STATUS_STUCK;
    case 15:
    case "STATUS_UNRECOGNIZED_COMMAND":
      return NavigateToAnchorResponse_Status.STATUS_UNRECOGNIZED_COMMAND;
    case 16:
    case "STATUS_INVALID_POSE":
      return NavigateToAnchorResponse_Status.STATUS_INVALID_POSE;
    case -1:
    case "UNRECOGNIZED":
    default:
      return NavigateToAnchorResponse_Status.UNRECOGNIZED;
  }
}

export function navigateToAnchorResponse_StatusToJSON(
  object: NavigateToAnchorResponse_Status
): string {
  switch (object) {
    case NavigateToAnchorResponse_Status.STATUS_UNKNOWN:
      return "STATUS_UNKNOWN";
    case NavigateToAnchorResponse_Status.STATUS_OK:
      return "STATUS_OK";
    case NavigateToAnchorResponse_Status.STATUS_NO_TIMESYNC:
      return "STATUS_NO_TIMESYNC";
    case NavigateToAnchorResponse_Status.STATUS_EXPIRED:
      return "STATUS_EXPIRED";
    case NavigateToAnchorResponse_Status.STATUS_TOO_DISTANT:
      return "STATUS_TOO_DISTANT";
    case NavigateToAnchorResponse_Status.STATUS_ROBOT_IMPAIRED:
      return "STATUS_ROBOT_IMPAIRED";
    case NavigateToAnchorResponse_Status.STATUS_RECORDING:
      return "STATUS_RECORDING";
    case NavigateToAnchorResponse_Status.STATUS_NO_ANCHORING:
      return "STATUS_NO_ANCHORING";
    case NavigateToAnchorResponse_Status.STATUS_NO_PATH:
      return "STATUS_NO_PATH";
    case NavigateToAnchorResponse_Status.STATUS_FEATURE_DESERT:
      return "STATUS_FEATURE_DESERT";
    case NavigateToAnchorResponse_Status.STATUS_LOST:
      return "STATUS_LOST";
    case NavigateToAnchorResponse_Status.STATUS_NOT_LOCALIZED_TO_MAP:
      return "STATUS_NOT_LOCALIZED_TO_MAP";
    case NavigateToAnchorResponse_Status.STATUS_COULD_NOT_UPDATE_ROUTE:
      return "STATUS_COULD_NOT_UPDATE_ROUTE";
    case NavigateToAnchorResponse_Sta