spot-sdk-ts/dist/bosdyn/api/graph_nav/graph_nav.d.ts

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

import { SE2TrajectoryCommand_Feedback_BodyMovementStatus } from "../basic_command";
import { LicenseInfo_Status } from "../license";
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 declare 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 declare 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 declare function setLocalizationRequest_FiducialInitFromJSON(object: any): SetLocalizationRequest_FiducialInit;
export declare function setLocalizationRequest_FiducialInitToJSON(object: SetLocalizationRequest_FiducialInit): string;
/**
 * 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 declare 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 declare function setLocalizationResponse_StatusFromJSON(object: any): SetLocalizationResponse_Status;
export declare function setLocalizationResponse_StatusToJSON(object: SetLocalizationResponse_Status): string;
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 declare 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 declare function travelParams_FeatureQualityToleranceFromJSON(object: any): TravelParams_FeatureQualityTolerance;
export declare function travelParams_FeatureQualityToleranceToJSON(object: TravelParams_FeatureQualityTolerance): string;
/**
 * 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 declare 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 declare function navigateToResponse_StatusFromJSON(object: any): NavigateToResponse_Status;
export declare function navigateToResponse_StatusToJSON(object: NavigateToResponse_Status): string;
/** 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 declare 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 declare function routeFollowingParams_StartRouteBehaviorFromJSON(object: any): RouteFollowingParams_StartRouteBehavior;
export declare function routeFollowingParams_StartRouteBehaviorToJSON(object: RouteFollowingParams_StartRouteBehavior): string;
/**
 * 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 declare 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 declare function routeFollowingParams_ResumeBehaviorFromJSON(object: any): RouteFollowingParams_ResumeBehavior;
export declare function routeFollowingParams_ResumeBehaviorToJSON(object: RouteFollowingParams_ResumeBehavior): string;
/** This setting applies when the robot discovers that the route is blocked. */
export declare 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 declare function routeFollowingParams_RouteBlockedBehaviorFromJSON(object: any): RouteFollowingParams_RouteBlockedBehavior;
export declare function routeFollowingParams_RouteBlockedBehaviorToJSON(object: RouteFollowingParams_RouteBlockedBehavior): string;
/**
 * 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 declare 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 declare function navigateRouteResponse_StatusFromJSON(object: any): NavigateRouteResponse_Status;
export declare function navigateRouteResponse_StatusToJSON(object: NavigateRouteResponse_Status): string;
/**
 * 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 declare 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 declare function navigateToAnchorResponse_StatusFromJSON(object: any): NavigateToAnchorResponse_Status;
export declare function navigateToAnchorResponse_StatusToJSON(object: NavigateToAnchorResponse_Status): string;
/**
 * The NavigationFeedback request message uses the command_id of a navigation request to get
 * the robot's progress and current status for the command. Note that all commands return immediately
 * after they are processed, and the robot will continue to execute the command asynchronously until
 * it times out or completes. New commands override old ones.
 */
export interface NavigationFeedbackRequest {
    /** Common request header. */
    header: RequestHeader | undefined;
    /**
     * Unique identifier for the command, provided by nav command response.
     * Omit to get feedback on currently executing command.
     */
    commandId: number;
}
/**
 * The NavigationFeedback response message returns the robot's
 * progress and current status for the command.
 */
export interface NavigationFeedbackResponse {
    /** Common response header. */
    header: ResponseHeader | undefined;
    /** Return status for the request. */
    status: NavigationFeedbackResponse_Status;
    /** If the status is ROBOT_IMPAIRED, this is why the robot is impaired. */
    impairedState: RobotImpairedState | undefined;
    /** Remaining part of current route. */
    remainingRoute: Route | undefined;
    /** ID of the command this feedback corresponds to. */
    commandId: number;
    /** The most recent transform describing the robot's pose relative to the navigation goal. */
    lastKoTformGoal: SE3Pose | undefined;
    /** Indicates whether the robot's body is currently in motion. */
    bodyMovementStatus: SE2TrajectoryCommand_Feedback_BodyMovementStatus;
}
export declare enum NavigationFeedbackResponse_Status {
    /** STATUS_UNKNOWN - An unknown / unexpected error occurred. */
    STATUS_UNKNOWN = 0,
    /** STATUS_FOLLOWING_ROUTE - The robot is currently, successfully following the route. */
    STATUS_FOLLOWING_ROUTE = 1,
    /** STATUS_REACHED_GOAL - The robot has reached the final goal of the navigation request. */
    STATUS_REACHED_GOAL = 2,
    /**
     * STATUS_NO_ROUTE - There's no route currently being navigated.
     * This can happen if no command has been issued, or if the graph has been changed during
     * navigation.
     */
    STATUS_NO_ROUTE = 3,
    /** STATUS_NO_LOCALIZATION - Robot is not localized to a route. */
    STATUS_NO_LOCALIZATION = 4,
    /** STATUS_LOST - Robot appears to be lost. */
    STATUS_LOST = 5,
    /** STATUS_STUCK - Robot appears stuck against an obstacle. */
    STATUS_STUCK = 6,
    /** STATUS_COMMAND_TIMED_OUT - The command expired. */
    STATUS_COMMAND_TIMED_OUT = 7,
    /**
     * STATUS_ROBOT_IMPAIRED - Cannot navigate a route if the robot has a crtical perception fault, or behavior fault,
     * or LIDAR not working. See impared_status for details.
     */
    STATUS_ROBOT_IMPAIRED = 8,
    /** STATUS_CONSTRAINT_FAULT - The route constraints were not feasible. */
    STATUS_CONSTRAINT_FAULT = 11,
    /** STATUS_COMMAND_OVERRIDDEN - The command was replaced by a new command */
    STATUS_COMMAND_OVERRIDDEN = 12,
    /** STATUS_NOT_LOCALIZED_TO_ROUTE - The localization or route changed mid-traverse. */
    STATUS_NOT_LOCALIZED_TO_ROUTE = 13,
    /** STATUS_LEASE_ERROR - The lease is no longer valid. */
    STATUS_LEASE_ERROR = 14,
    UNRECOGNIZED = -1
}
export declare function navigationFeedbackResponse_StatusFromJSON(object: any): NavigationFeedbackResponse_Status;
export declare function navigationFeedbackResponse_StatusToJSON(object: NavigationFeedbackResponse_Status): string;
/**
 * The GetLocalizationState request message requests the current localization state and any other
 * live data from the robot if desired. The localization consists of a waypoint ID and the relative
 * pose of the robot with respect to that waypoint.
 */
export interface GetLocalizationStateRequest {
    /** Common request header. */
    header: RequestHeader | undefined;
    /** Return the localization relative to this waypoint, if specified. */
    waypointId: string;
    /**
     * If true, request the live edge-segmented point cloud that was used
     * to generate this localization.
     */
    requestLivePointCloud: boolean;
    /**
     * If true, request the live images from realsense cameras at the time of
     * localization.
     */
    requestLiveImages: boolean;
    /** If true, request the live terrain maps at the time of localization. */
    requestLiveTerrainMaps: boolean;
    /** If true, reqeuest the live world objects at the time of localization. */
    requestLiveWorldObjects: boolean;
    /** If true, requests the full live robot state at the time of localization. */
    requestLiveRobotState: boolean;
    /**
     * If true, the smallest available encoding will be used for the live point cloud
     * data. If false, three 32 bit floats will be used per point in the point cloud.
     */
    compressLivePointCloud: boolean;
}
/** Message describing the state of a remote point cloud service (such as a velodyne). */
export interface RemotePointCloudStatus {
    /** The name of the point cloud service. */
    serviceName: string;
    /**
     * Boolean indicating if the point cloud service was registered in the robot's directory with
     * the provided name.
     */
    existsInDirectory: boolean;
    /** Boolean indicating if the point cloud service is currently outputting data. */
    hasData: boolean;
}
/**
 * Message describing whether or not graph nav is lost, and if it is lost, how lost it is.
 * If robot is lost, this state can be reset by either:
 *    * Driving to an area where the robot's localization improves.
 *    * Calling SetLocalization RPC.
 */
export interface LostDetectorState {
    /**
     * Whether or not the robot is currently lost.  If this is true, graph nav will reject
     * NavigateTo or NavigateRoute RPC's.
     */
    isLost: boolean;
}
/**
 * The GetLocalizationState response message returns the current localization and robot state, as well
 * as any requested live data information.
 */
export interface GetLocalizationStateResponse {
    /** Common response header. */
    header: ResponseHeader | undefined;
    /**
     * Where the robot currently is. If a waypoint_id was specified in the request, this localization
     * will be relative to that waypoint.
     */
    localization: Localization | undefined;
    /** Robot kinematic state at time of localization. */
    robotKinematics: KinematicState | undefined;
    /** Status of one or more remote point cloud services (such as velodyne). */
    remoteCloudStatus: RemotePointCloudStatus[];
    /**
     * Contains live data at the time of localization, with elements only filled out
     * if requested.
     */
    liveData: WaypointSnapshot | undefined;
    /**
     * If the robot drives around without a good localization for a while, eventually
     * it becomes "lost."  I.E. it has a localization, but it no longer trusts
     * that the localization it has is accurate.  Lost detector state is
     * available through this message.
     */
    lostDetectorState: LostDetectorState | undefined;
}
/**
 * Clears the graph on the server. Also clears GraphNav's localization to the graph.
 * Note that waypoint and edge snapshots may still be cached on the server after this
 * operation. This RPC may not be used while recording a map.
 */
export interface ClearGraphRequest {
    /** Common request header. */
    header: RequestHeader | undefined;
    /** The Lease to show ownership of graph-nav service. */
    lease: Lease | undefined;
}
/** The results of the ClearGraphRequest. */
export interface ClearGraphResponse {
    /** Common response header. */
    header: ResponseHeader | undefined;
    /** Details about how the lease was used. */
    leaseUseResult: LeaseUseResult | undefined;
    /** Status of the ClearGraphResponse. */
    status: ClearGraphResponse_Status;
}
export declare enum ClearGraphResponse_Status {
    STATUS_UNKNOWN = 0,
    STATUS_OK = 1,
    /**
     * STATUS_RECORDING - Graph Nav is currently recording a map. You must call
     * StopRecording from the recording service to continue.
     */
    STATUS_RECORDING = 2,
    UNRECOGNIZED = -1
}
export declare function clearGraphResponse_StatusFromJSON(object: any): ClearGraphResponse_Status;
export declare function clearGraphResponse_StatusToJSON(object: ClearGraphResponse_Status): string;
/**
 * Uploads a graph to the server. This graph will be appended to the graph that
 * currently exists on the server.
 */
export interface UploadGraphRequest {
    /** Common request header. */
    header: RequestHeader | undefined;
    /**
     * Structure of the graph containing waypoints and edges without
     * underlying sensor data.
     */
    graph: Graph | undefined;
    /** The Lease to show ownership of graph-nav service. */
    lease: Lease | undefined;
    /** If this is true, generate an (overwrite the) anchoring on upload. */
    generateNewAnchoring: boolean;
}
/**
 * Response to the UploadGraphRequest. After uploading a graph, the user is expected
 * to upload large data at waypoints and edges (called snapshots). The response provides
 * a list of snapshot IDs which are not yet cached on the server. Snapshots with these IDs should
 * be uploaded by the client.
 */
export interface UploadGraphResponse {
    /** Common response header. */
    header: ResponseHeader | undefined;
    /** Status for an upload request. */
    status: UploadGraphResponse_Status;
    /** Details about how the lease was used. */
    leaseUseResult: LeaseUseResult | undefined;
    /** The waypoint snapshot ids for which there was cached data. */
    loadedWaypointSnapshotIds: string[];
    /** The waypoint snapshot ids for which there is no cached data. */
    unknownWaypointSnapshotIds: string[];
    /** The edge snapshot ids for which there was cached data. */
    loadedEdgeSnapshotIds: string[];
    /** The edge snapshot ids for which there was no cached data. */
    unknownEdgeSnapshotIds: string[];
    /** Large graphs can only be uploaded if the license permits them. */
    licenseStatus: LicenseInfo_Status;
    sensorStatus: SensorCompatibilityStatus | undefined;
}
export declare enum UploadGraphResponse_Status {
    STATUS_UNKNOWN = 0,
    STATUS_OK = 1,
    /** STATUS_MAP_TOO_LARGE_LICENSE - Can't upload the graph because it was too large for the license. */
    STATUS_MAP_TOO_LARGE_LICENSE = 3,
    /** STATUS_INVALID_GRAPH - The graph is invalid topologically, for example containing missing waypoints referenced by edges. */
    STATUS_INVALID_GRAPH = 4,
    STATUS_INCOMPATIBLE_SENSORS = 5,
    UNRECOGNIZED = -1
}
export declare function uploadGraphResponse_StatusFromJSON(object: any): UploadGraphResponse_Status;
export declare function uploadGraphResponse_StatusToJSON(object: UploadGraphResponse_Status): string;
/**
 * The DownloadGraphRequest requests that the server send the graph (waypoints and edges)
 * to the client. Note that the returned Graph message contains only the topological
 * structure of the map, and not any large sensor data. Large sensor data should be downloaded
 * using DownloadWaypointSnapshotRequest and DownloadEdgeSnapshotRequest. Both snapshots and
 * the graph are required to exist on the server for GraphNav to localize and navigate.
 */
export interface DownloadGraphRequest {
    /** Common request header. */
    header: RequestHeader | undefined;
}
/** The DownloadGraph response message includes the current graph on the robot. */
export interface DownloadGraphResponse {
    /** Common request header. */
    header: ResponseHeader | undefined;
    /** The structure of the graph. */
    graph: Graph | undefined;
}
/**
 * Used to upload waypoint snapshot in chunks for a specific waypoint snapshot. Waypoint
 * snapshots consist of the large sensor data at each waypoint.
 * Chunks will be streamed one at a time to the server. Chunk streaming is required to prevent
 * overwhelming gRPC with large http requests.
 */
export interface UploadWaypointSnapshotRequest {
    /** Common response header. */
    header: RequestHeader | undefined;
    /**
     * Serialized bytes of a WaypointSnapshot message, restricted to a chunk no larger than 4MB in size.
     * To break the data into chunks, first serialize it to bytes. Then, send the bytes in order as DataChunk objects.
     * The chunks will be concatenated together on the server, and deserialized.
     */
    chunk: DataChunk | undefined;
    /** The Leases to show ownership of the graph-nav service. */
    lease: Lease | undefined;
}
/**
 * One response for the entire WaypointSnapshot after all chunks have
 * been concatenated and deserialized.
 */
export interface UploadWaypointSnapshotResponse {
    /** Common response header. */
    header: ResponseHeader | undefined;
    /** Details about how the lease was used. */
    leaseUseResult: LeaseUseResult | undefined;
    status: UploadWaypointSnapshotResponse_Status;
    sensorStatus: SensorCompatibilityStatus | undefined;
}
export declare enum UploadWaypointSnapshotResponse_Status {
    /** STATUS_UNKNOWN - Unset. */
    STATUS_UNKNOWN = 0,
    /** STATUS_OK - Success. */
    STATUS_OK = 1,
    /**
     * STATUS_INCOMPATIBLE_SENSORS - The data in this waypoint snapshot is not compatible with the
     * current configuration of the robot. Check sensor_status for
     * more details.
     */
    STATUS_INCOMPATIBLE_SENSORS = 2,
    UNRECOGNIZED = -1
}
export declare function uploadWaypointSnapshotResponse_StatusFromJSON(object: any): UploadWaypointSnapshotResponse_Status;
export declare function uploadWaypointSnapshotResponse_StatusToJSON(object: UploadWaypointSnapshotResponse_Status): string;
/**
 * Used to upload edge data in chunks for a specific edge snapshot. Edge snapshots contain
 * large sensor data associated with each edge.
 * Chunks will be streamed one at a time to the server. Chunk streaming is required to prevent
 * overwhelming gRPC with large http requests.
 */
export interface UploadEdgeSnapshotRequest {
    /** Common response header. */
    header: RequestHeader | undefined;
    /**
     * Serialized bytes of a EdgeSnapshot message, restricted to a chunk no larger than 4MB in size.
     * To break the data into chunks, first serialize it to bytes. Then, send the bytes in order as DataChunk objects.
     * The chunks will be concatenated together on the server, and deserialized
     */
    chunk: DataChunk | undefined;
    /** The Leases to show ownership of the graph-nav service. */
    lease: Lease | undefined;
}
/**
 * One response for the entire EdgeSnapshot after all chunks have
 * been concatenated and deserialized.
 */
export interface UploadEdgeSnapshotResponse {
    /** Common response header. */
    header: ResponseHeader | undefined;
    /** Details about how the lease was used. */
    leaseUseResult: LeaseUseResult | undefined;
}
/**
 * The DownloadWaypointSnapshot request asks for a specific waypoint snapshot id to
 * be downloaded and has parameters to decrease the amount of data downloaded. After
 * recording a map, first call the DownloadGraph RPC. Then, for each waypoint snapshot id,
 * request the waypoint snapshot from the server using the DownloadWaypointSnapshot RPC.
 */
export interface DownloadWaypointSnapshotRequest {
    /** Common request header. */
    header: RequestHeader | undefined;
    /** ID of the snapshot associated with a waypoint. */
    waypointSnapshotId: string;
    /**
     * If true, download the full images and point clouds from
     * each camera.
     */
    downloadImages: boolean;
    /**
     * If true, the point cloud will be compressed using the smallest
     * available point cloud encoding. If false, three 32-bit floats will
     * be used per point.
     */
    compressPointCloud: boolean;
    /**
     * Skip downloading the point cloud, and only download other data such as images or world
     * objects.
     */
    doNotDownloadPointCloud: boolean;
}
/**
 * The DownloadWaypointSnapshot response streams the data of the waypoint snapshot id
 * currently being downloaded in data chunks no larger than 4MB in size. It is necessary
 * to stream these data to avoid overwhelming gRPC with large http requests.
 */
export interface DownloadWaypointSnapshotResponse {
    /** Common response header. */
    header: ResponseHeader | undefined;
    /** Return status for the request. */
    status: DownloadWaypointSnapshotResponse_Status;
    /** ID of the snapshot associated with a waypoint. */
    waypointSnapshotId: string;
    /**
     * Chunk of data to download. Responses are sent in sequence until the
     * data chunk is complete. After receiving all chunks, concatenate them
     * into a single byte string. Then, deserialize the byte string into a
     * WaypointSnapshot object.
     */
    chunk: DataChunk | undefined;
}
export declare enum DownloadWaypointSnapshotResponse_Status {
    STATUS_UNKNOWN = 0,
    STATUS_OK = 1,
    /** STATUS_SNAPSHOT_DOES_NOT_EXIST - Error where the given snapshot ID does not exist. */
    STATUS_SNAPSHOT_DOES_NOT_EXIST = 2,
    UNRECOGNIZED = -1
}
export declare function downloadWaypointSnapshotResponse_StatusFromJSON(object: any): DownloadWaypointSnapshotResponse_Status;
export declare function downloadWaypointSnapshotResponse_StatusToJSON(object: DownloadWaypointSnapshotResponse_Status): string;
/**
 * The DownloadEdgeSnapshot request asks for a specific edge snapshot id to
 * be downloaded. Edge snapshots contain the large sensor data stored in each edge.
 */
export interface DownloadEdgeSnapshotRequest {
    /** Common request header. */
    header: RequestHeader | undefined;
    /** ID of the data associated with an edge. */
    edgeSn