// @generated by protoc-gen-es v1.10.0
// @generated from file component/arm/v1/arm.proto (package viam.component.arm.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck

import type { BinaryReadOptions, Duration, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage, Struct } from "@bufbuild/protobuf";
import { Message, proto3 } from "@bufbuild/protobuf";
import type { Pose } from "../../../common/v1/common_pb.js";

/**
 * @generated from message viam.component.arm.v1.GetEndPositionRequest
 */
export declare class GetEndPositionRequest extends Message<GetEndPositionRequest> {
  /**
   * Name of an arm
   *
   * @generated from field: string name = 1;
   */
  name: string;

  /**
   * Additional arguments to the method
   *
   * @generated from field: google.protobuf.Struct extra = 99;
   */
  extra?: Struct;

  constructor(data?: PartialMessage<GetEndPositionRequest>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.component.arm.v1.GetEndPositionRequest";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetEndPositionRequest;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetEndPositionRequest;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetEndPositionRequest;

  static equals(a: GetEndPositionRequest | PlainMessage<GetEndPositionRequest> | undefined, b: GetEndPositionRequest | PlainMessage<GetEndPositionRequest> | undefined): boolean;
}

/**
 * @generated from message viam.component.arm.v1.GetEndPositionResponse
 */
export declare class GetEndPositionResponse extends Message<GetEndPositionResponse> {
  /**
   * Returns 6d pose of the end effector relative to the base, represented by X,Y,Z coordinates which express
   * millimeters and theta, ox, oy, oz coordinates which express an orientation vector
   *
   * @generated from field: viam.common.v1.Pose pose = 1;
   */
  pose?: Pose;

  constructor(data?: PartialMessage<GetEndPositionResponse>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.component.arm.v1.GetEndPositionResponse";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetEndPositionResponse;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetEndPositionResponse;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetEndPositionResponse;

  static equals(a: GetEndPositionResponse | PlainMessage<GetEndPositionResponse> | undefined, b: GetEndPositionResponse | PlainMessage<GetEndPositionResponse> | undefined): boolean;
}

/**
 * @generated from message viam.component.arm.v1.JointPositions
 */
export declare class JointPositions extends Message<JointPositions> {
  /**
   * A list of joint positions. Rotations values are in degrees, translational values in mm.
   * There should be 1 entry in the list per joint DOF, ordered spatially from the base toward the end effector of the arm
   *
   * @generated from field: repeated double values = 1;
   */
  values: number[];

  constructor(data?: PartialMessage<JointPositions>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.component.arm.v1.JointPositions";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): JointPositions;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): JointPositions;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): JointPositions;

  static equals(a: JointPositions | PlainMessage<JointPositions> | undefined, b: JointPositions | PlainMessage<JointPositions> | undefined): boolean;
}

/**
 * @generated from message viam.component.arm.v1.JointVelocities
 */
export declare class JointVelocities extends Message<JointVelocities> {
  /**
   * A list of joint velocities. Rotational values are in degrees per second, translational values in mm per second.
   * There should be 1 entry in the list per joint DOF, ordered spatially from the base toward the end effector of the arm.
   *
   * @generated from field: repeated double values = 1;
   */
  values: number[];

  constructor(data?: PartialMessage<JointVelocities>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.component.arm.v1.JointVelocities";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): JointVelocities;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): JointVelocities;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): JointVelocities;

  static equals(a: JointVelocities | PlainMessage<JointVelocities> | undefined, b: JointVelocities | PlainMessage<JointVelocities> | undefined): boolean;
}

/**
 * @generated from message viam.component.arm.v1.JointAccelerations
 */
export declare class JointAccelerations extends Message<JointAccelerations> {
  /**
   * A list of joint accelerations. Rotational values are in degrees per second squared, translational values in mm per second squared.
   * There should be 1 entry in the list per joint DOF, ordered spatially from the base toward the end effector of the arm.
   *
   * @generated from field: repeated double values = 1;
   */
  values: number[];

  constructor(data?: PartialMessage<JointAccelerations>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.component.arm.v1.JointAccelerations";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): JointAccelerations;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): JointAccelerations;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): JointAccelerations;

  static equals(a: JointAccelerations | PlainMessage<JointAccelerations> | undefined, b: JointAccelerations | PlainMessage<JointAccelerations> | undefined): boolean;
}

/**
 * @generated from message viam.component.arm.v1.GetJointPositionsRequest
 */
export declare class GetJointPositionsRequest extends Message<GetJointPositionsRequest> {
  /**
   * Name of an arm
   *
   * @generated from field: string name = 1;
   */
  name: string;

  /**
   * Additional arguments to the method
   *
   * @generated from field: google.protobuf.Struct extra = 99;
   */
  extra?: Struct;

  constructor(data?: PartialMessage<GetJointPositionsRequest>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.component.arm.v1.GetJointPositionsRequest";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetJointPositionsRequest;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetJointPositionsRequest;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetJointPositionsRequest;

  static equals(a: GetJointPositionsRequest | PlainMessage<GetJointPositionsRequest> | undefined, b: GetJointPositionsRequest | PlainMessage<GetJointPositionsRequest> | undefined): boolean;
}

/**
 * @generated from message viam.component.arm.v1.GetJointPositionsResponse
 */
export declare class GetJointPositionsResponse extends Message<GetJointPositionsResponse> {
  /**
   * a list JointPositions
   *
   * @generated from field: viam.component.arm.v1.JointPositions positions = 1;
   */
  positions?: JointPositions;

  constructor(data?: PartialMessage<GetJointPositionsResponse>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.component.arm.v1.GetJointPositionsResponse";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetJointPositionsResponse;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetJointPositionsResponse;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetJointPositionsResponse;

  static equals(a: GetJointPositionsResponse | PlainMessage<GetJointPositionsResponse> | undefined, b: GetJointPositionsResponse | PlainMessage<GetJointPositionsResponse> | undefined): boolean;
}

/**
 * Moves an arm to the specified pose that is within the reference frame of the arm.
 * Move request in Motion API has the same behavior except that it performs obstacle avoidance when a world_state
 * message is specified.
 *
 * @generated from message viam.component.arm.v1.MoveToPositionRequest
 */
export declare class MoveToPositionRequest extends Message<MoveToPositionRequest> {
  /**
   * Name of an arm
   *
   * @generated from field: string name = 1;
   */
  name: string;

  /**
   * The destination to move the arm to; this is from the reference frame of the arm.
   *
   * @generated from field: viam.common.v1.Pose to = 2;
   */
  to?: Pose;

  /**
   * Additional arguments to the method
   *
   * @generated from field: google.protobuf.Struct extra = 99;
   */
  extra?: Struct;

  constructor(data?: PartialMessage<MoveToPositionRequest>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.component.arm.v1.MoveToPositionRequest";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MoveToPositionRequest;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MoveToPositionRequest;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MoveToPositionRequest;

  static equals(a: MoveToPositionRequest | PlainMessage<MoveToPositionRequest> | undefined, b: MoveToPositionRequest | PlainMessage<MoveToPositionRequest> | undefined): boolean;
}

/**
 * @generated from message viam.component.arm.v1.MoveToPositionResponse
 */
export declare class MoveToPositionResponse extends Message<MoveToPositionResponse> {
  constructor(data?: PartialMessage<MoveToPositionResponse>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.component.arm.v1.MoveToPositionResponse";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MoveToPositionResponse;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MoveToPositionResponse;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MoveToPositionResponse;

  static equals(a: MoveToPositionResponse | PlainMessage<MoveToPositionResponse> | undefined, b: MoveToPositionResponse | PlainMessage<MoveToPositionResponse> | undefined): boolean;
}

/**
 * @generated from message viam.component.arm.v1.MoveToJointPositionsRequest
 */
export declare class MoveToJointPositionsRequest extends Message<MoveToJointPositionsRequest> {
  /**
   * Name of an arm
   *
   * @generated from field: string name = 1;
   */
  name: string;

  /**
   * A list of joint positions
   * There should be 1 entry in the list per joint DOF, ordered spatially from the base toward the end effector
   *
   * @generated from field: viam.component.arm.v1.JointPositions positions = 2;
   */
  positions?: JointPositions;

  /**
   * Additional arguments to the method
   *
   * @generated from field: google.protobuf.Struct extra = 99;
   */
  extra?: Struct;

  constructor(data?: PartialMessage<MoveToJointPositionsRequest>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.component.arm.v1.MoveToJointPositionsRequest";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MoveToJointPositionsRequest;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MoveToJointPositionsRequest;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MoveToJointPositionsRequest;

  static equals(a: MoveToJointPositionsRequest | PlainMessage<MoveToJointPositionsRequest> | undefined, b: MoveToJointPositionsRequest | PlainMessage<MoveToJointPositionsRequest> | undefined): boolean;
}

/**
 * @generated from message viam.component.arm.v1.MoveToJointPositionsResponse
 */
export declare class MoveToJointPositionsResponse extends Message<MoveToJointPositionsResponse> {
  constructor(data?: PartialMessage<MoveToJointPositionsResponse>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.component.arm.v1.MoveToJointPositionsResponse";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MoveToJointPositionsResponse;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MoveToJointPositionsResponse;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MoveToJointPositionsResponse;

  static equals(a: MoveToJointPositionsResponse | PlainMessage<MoveToJointPositionsResponse> | undefined, b: MoveToJointPositionsResponse | PlainMessage<MoveToJointPositionsResponse> | undefined): boolean;
}

/**
 * @generated from message viam.component.arm.v1.MoveThroughJointPositionsRequest
 */
export declare class MoveThroughJointPositionsRequest extends Message<MoveThroughJointPositionsRequest> {
  /**
   * Name of an arm
   *
   * @generated from field: string name = 1;
   */
  name: string;

  /**
   * A list of joint positions which will be moved to in the order they are specified
   *
   * @generated from field: repeated viam.component.arm.v1.JointPositions positions = 2;
   */
  positions: JointPositions[];

  /**
   * optional specifications to be obeyed during the motion
   *
   * @generated from field: optional viam.component.arm.v1.MoveOptions options = 3;
   */
  options?: MoveOptions;

  /**
   * Additional arguments to the method
   *
   * @generated from field: google.protobuf.Struct extra = 99;
   */
  extra?: Struct;

  constructor(data?: PartialMessage<MoveThroughJointPositionsRequest>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.component.arm.v1.MoveThroughJointPositionsRequest";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MoveThroughJointPositionsRequest;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MoveThroughJointPositionsRequest;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MoveThroughJointPositionsRequest;

  static equals(a: MoveThroughJointPositionsRequest | PlainMessage<MoveThroughJointPositionsRequest> | undefined, b: MoveThroughJointPositionsRequest | PlainMessage<MoveThroughJointPositionsRequest> | undefined): boolean;
}

/**
 * @generated from message viam.component.arm.v1.MoveThroughJointPositionsResponse
 */
export declare class MoveThroughJointPositionsResponse extends Message<MoveThroughJointPositionsResponse> {
  constructor(data?: PartialMessage<MoveThroughJointPositionsResponse>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.component.arm.v1.MoveThroughJointPositionsResponse";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MoveThroughJointPositionsResponse;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MoveThroughJointPositionsResponse;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MoveThroughJointPositionsResponse;

  static equals(a: MoveThroughJointPositionsResponse | PlainMessage<MoveThroughJointPositionsResponse> | undefined, b: MoveThroughJointPositionsResponse | PlainMessage<MoveThroughJointPositionsResponse> | undefined): boolean;
}

/**
 * One waypoint in a streamed joint-space trajectory.
 *
 * @generated from message viam.component.arm.v1.TrajectoryPoint
 */
export declare class TrajectoryPoint extends Message<TrajectoryPoint> {
  /**
   * Time from the start of the motion at which this waypoint should be reached. Must be zero
   * for the first point of the stream and strictly increasing thereafter. Server implementations
   * should validate these constraints.
   *
   * @generated from field: google.protobuf.Duration time = 1;
   */
  time?: Duration;

  /**
   * Joint positions at this waypoint.
   *
   * @generated from field: viam.component.arm.v1.JointPositions positions = 2;
   */
  positions?: JointPositions;

  /**
   * Optional target kinematic constraints at this waypoint.
   *
   * @generated from field: optional viam.component.arm.v1.TrajectoryPoint.KinematicConstraints constraints = 3;
   */
  constraints?: TrajectoryPoint_KinematicConstraints;

  constructor(data?: PartialMessage<TrajectoryPoint>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.component.arm.v1.TrajectoryPoint";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TrajectoryPoint;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TrajectoryPoint;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TrajectoryPoint;

  static equals(a: TrajectoryPoint | PlainMessage<TrajectoryPoint> | undefined, b: TrajectoryPoint | PlainMessage<TrajectoryPoint> | undefined): boolean;
}

/**
 * @generated from message viam.component.arm.v1.TrajectoryPoint.KinematicConstraints
 */
export declare class TrajectoryPoint_KinematicConstraints extends Message<TrajectoryPoint_KinematicConstraints> {
  /**
   * Target joint velocities at this waypoint. If provided, the first point of the stream (the t=0 sample)
   * must have zero velocity. Server implementations should validate this constraint.
   *
   * @generated from field: viam.component.arm.v1.JointVelocities velocities = 1;
   */
  velocities?: JointVelocities;

  /**
   * Optional target joint accelerations at this waypoint.
   *
   * @generated from field: optional viam.component.arm.v1.JointAccelerations accelerations = 2;
   */
  accelerations?: JointAccelerations;

  constructor(data?: PartialMessage<TrajectoryPoint_KinematicConstraints>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.component.arm.v1.TrajectoryPoint.KinematicConstraints";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TrajectoryPoint_KinematicConstraints;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TrajectoryPoint_KinematicConstraints;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TrajectoryPoint_KinematicConstraints;

  static equals(a: TrajectoryPoint_KinematicConstraints | PlainMessage<TrajectoryPoint_KinematicConstraints> | undefined, b: TrajectoryPoint_KinematicConstraints | PlainMessage<TrajectoryPoint_KinematicConstraints> | undefined): boolean;
}

/**
 * @generated from message viam.component.arm.v1.MoveThroughJointPositionsStreamedRequest
 */
export declare class MoveThroughJointPositionsStreamedRequest extends Message<MoveThroughJointPositionsStreamedRequest> {
  /**
   * Name of the arm to control.
   *
   * @generated from field: string name = 1;
   */
  name: string;

  /**
   * @generated from oneof viam.component.arm.v1.MoveThroughJointPositionsStreamedRequest.message
   */
  message: {
    /**
     * Stream initiation. Sent exactly once and must be the first message on the stream.
     *
     * @generated from field: viam.component.arm.v1.MoveThroughJointPositionsStreamedRequest.Init init = 2;
     */
    value: MoveThroughJointPositionsStreamedRequest_Init;
    case: "init";
  } | {
    /**
     * A batch of trajectory points to append to the running motion. Sent N times after init.
     *
     * @generated from field: viam.component.arm.v1.MoveThroughJointPositionsStreamedRequest.TrajectoryBatch batch = 3;
     */
    value: MoveThroughJointPositionsStreamedRequest_TrajectoryBatch;
    case: "batch";
  } | { case: undefined; value?: undefined };

  constructor(data?: PartialMessage<MoveThroughJointPositionsStreamedRequest>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.component.arm.v1.MoveThroughJointPositionsStreamedRequest";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MoveThroughJointPositionsStreamedRequest;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MoveThroughJointPositionsStreamedRequest;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MoveThroughJointPositionsStreamedRequest;

  static equals(a: MoveThroughJointPositionsStreamedRequest | PlainMessage<MoveThroughJointPositionsStreamedRequest> | undefined, b: MoveThroughJointPositionsStreamedRequest | PlainMessage<MoveThroughJointPositionsStreamedRequest> | undefined): boolean;
}

/**
 * @generated from message viam.component.arm.v1.MoveThroughJointPositionsStreamedRequest.Init
 */
export declare class MoveThroughJointPositionsStreamedRequest_Init extends Message<MoveThroughJointPositionsStreamedRequest_Init> {
  /**
   * Additional sticky arguments to the method.
   *
   * @generated from field: google.protobuf.Struct extra = 99;
   */
  extra?: Struct;

  constructor(data?: PartialMessage<MoveThroughJointPositionsStreamedRequest_Init>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.component.arm.v1.MoveThroughJointPositionsStreamedRequest.Init";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MoveThroughJointPositionsStreamedRequest_Init;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MoveThroughJointPositionsStreamedRequest_Init;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MoveThroughJointPositionsStreamedRequest_Init;

  static equals(a: MoveThroughJointPositionsStreamedRequest_Init | PlainMessage<MoveThroughJointPositionsStreamedRequest_Init> | undefined, b: MoveThroughJointPositionsStreamedRequest_Init | PlainMessage<MoveThroughJointPositionsStreamedRequest_Init> | undefined): boolean;
}

/**
 * @generated from message viam.component.arm.v1.MoveThroughJointPositionsStreamedRequest.TrajectoryBatch
 */
export declare class MoveThroughJointPositionsStreamedRequest_TrajectoryBatch extends Message<MoveThroughJointPositionsStreamedRequest_TrajectoryBatch> {
  /**
   * Trajectory points to append to the motion, in order. Append-only; points cannot be
   * replaced or revoked.
   *
   * @generated from field: repeated viam.component.arm.v1.TrajectoryPoint points = 1;
   */
  points: TrajectoryPoint[];

  constructor(data?: PartialMessage<MoveThroughJointPositionsStreamedRequest_TrajectoryBatch>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.component.arm.v1.MoveThroughJointPositionsStreamedRequest.TrajectoryBatch";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MoveThroughJointPositionsStreamedRequest_TrajectoryBatch;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MoveThroughJointPositionsStreamedRequest_TrajectoryBatch;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MoveThroughJointPositionsStreamedRequest_TrajectoryBatch;

  static equals(a: MoveThroughJointPositionsStreamedRequest_TrajectoryBatch | PlainMessage<MoveThroughJointPositionsStreamedRequest_TrajectoryBatch> | undefined, b: MoveThroughJointPositionsStreamedRequest_TrajectoryBatch | PlainMessage<MoveThroughJointPositionsStreamedRequest_TrajectoryBatch> | undefined): boolean;
}

/**
 * Streamed back to the client while an arm is performing a streaming move.
 *
 * @generated from message viam.component.arm.v1.MoveThroughJointPositionsStreamedResponse
 */
export declare class MoveThroughJointPositionsStreamedResponse extends Message<MoveThroughJointPositionsStreamedResponse> {
  /**
   * This single-member `oneof` exists to future proof clients. We
   * anticipate that arm implementations may in the future elect to
   * return a wider variety of status updates during streaming, beyond
   * simply ack'ing batches. Using a `oneof` here ensures that the
   * addition of new update messages does not break existing clients.
   *
   * @generated from oneof viam.component.arm.v1.MoveThroughJointPositionsStreamedResponse.message
   */
  message: {
    /**
     * @generated from field: viam.component.arm.v1.MoveThroughJointPositionsStreamedResponse.BatchAck ack = 1;
     */
    value: MoveThroughJointPositionsStreamedResponse_BatchAck;
    case: "ack";
  } | { case: undefined; value?: undefined };

  constructor(data?: PartialMessage<MoveThroughJointPositionsStreamedResponse>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.component.arm.v1.MoveThroughJointPositionsStreamedResponse";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MoveThroughJointPositionsStreamedResponse;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MoveThroughJointPositionsStreamedResponse;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MoveThroughJointPositionsStreamedResponse;

  static equals(a: MoveThroughJointPositionsStreamedResponse | PlainMessage<MoveThroughJointPositionsStreamedResponse> | undefined, b: MoveThroughJointPositionsStreamedResponse | PlainMessage<MoveThroughJointPositionsStreamedResponse> | undefined): boolean;
}

/**
 * BatchAck is returned by arm implementations to ack a
 * `TrajectoryBatch`. Due to the lack of actionable payload in
 * `BatchAck`, Arm implementations are not currently obligated to
 * ack every batch, or even any batch. It is currently unspecified
 * whether ack'ing a batch indicates its acceptance, issue to the
 * arm, or completion. These very relaxed requirements may become
 * tighter if and when `BatchAck` messages begin carrying meaningful
 * payloads back to the client. For now, the recommended practice
 * for arm implementors is to ack each batch that has been
 * successfully issued/enqueued to the arm.
 *
 * @generated from message viam.component.arm.v1.MoveThroughJointPositionsStreamedResponse.BatchAck
 */
export declare class MoveThroughJointPositionsStreamedResponse_BatchAck extends Message<MoveThroughJointPositionsStreamedResponse_BatchAck> {
  /**
   * Additional reply data
   *
   * @generated from field: google.protobuf.Struct extra = 99;
   */
  extra?: Struct;

  constructor(data?: PartialMessage<MoveThroughJointPositionsStreamedResponse_BatchAck>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.component.arm.v1.MoveThroughJointPositionsStreamedResponse.BatchAck";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MoveThroughJointPositionsStreamedResponse_BatchAck;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MoveThroughJointPositionsStreamedResponse_BatchAck;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MoveThroughJointPositionsStreamedResponse_BatchAck;

  static equals(a: MoveThroughJointPositionsStreamedResponse_BatchAck | PlainMessage<MoveThroughJointPositionsStreamedResponse_BatchAck> | undefined, b: MoveThroughJointPositionsStreamedResponse_BatchAck | PlainMessage<MoveThroughJointPositionsStreamedResponse_BatchAck> | undefined): boolean;
}

/**
 * @generated from message viam.component.arm.v1.StopRequest
 */
export declare class StopRequest extends Message<StopRequest> {
  /**
   * Name of an arm
   *
   * @generated from field: string name = 1;
   */
  name: string;

  /**
   * Additional arguments to the method
   *
   * @generated from field: google.protobuf.Struct extra = 99;
   */
  extra?: Struct;

  constructor(data?: PartialMessage<StopRequest>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.component.arm.v1.StopRequest";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StopRequest;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StopRequest;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StopRequest;

  static equals(a: StopRequest | PlainMessage<StopRequest> | undefined, b: StopRequest | PlainMessage<StopRequest> | undefined): boolean;
}

/**
 * @generated from message viam.component.arm.v1.StopResponse
 */
export declare class StopResponse extends Message<StopResponse> {
  constructor(data?: PartialMessage<StopResponse>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.component.arm.v1.StopResponse";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StopResponse;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StopResponse;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StopResponse;

  static equals(a: StopResponse | PlainMessage<StopResponse> | undefined, b: StopResponse | PlainMessage<StopResponse> | undefined): boolean;
}

/**
 * @generated from message viam.component.arm.v1.Status
 */
export declare class Status extends Message<Status> {
  /**
   * @generated from field: viam.common.v1.Pose end_position = 1;
   */
  endPosition?: Pose;

  /**
   * @generated from field: viam.component.arm.v1.JointPositions joint_positions = 2;
   */
  jointPositions?: JointPositions;

  /**
   * @generated from field: bool is_moving = 3;
   */
  isMoving: boolean;

  constructor(data?: PartialMessage<Status>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.component.arm.v1.Status";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Status;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Status;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Status;

  static equals(a: Status | PlainMessage<Status> | undefined, b: Status | PlainMessage<Status> | undefined): boolean;
}

/**
 * @generated from message viam.component.arm.v1.IsMovingRequest
 */
export declare class IsMovingRequest extends Message<IsMovingRequest> {
  /**
   * @generated from field: string name = 1;
   */
  name: string;

  constructor(data?: PartialMessage<IsMovingRequest>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.component.arm.v1.IsMovingRequest";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): IsMovingRequest;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): IsMovingRequest;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): IsMovingRequest;

  static equals(a: IsMovingRequest | PlainMessage<IsMovingRequest> | undefined, b: IsMovingRequest | PlainMessage<IsMovingRequest> | undefined): boolean;
}

/**
 * @generated from message viam.component.arm.v1.IsMovingResponse
 */
export declare class IsMovingResponse extends Message<IsMovingResponse> {
  /**
   * @generated from field: bool is_moving = 1;
   */
  isMoving: boolean;

  constructor(data?: PartialMessage<IsMovingResponse>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.component.arm.v1.IsMovingResponse";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): IsMovingResponse;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): IsMovingResponse;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): IsMovingResponse;

  static equals(a: IsMovingResponse | PlainMessage<IsMovingResponse> | undefined, b: IsMovingResponse | PlainMessage<IsMovingResponse> | undefined): boolean;
}

/**
 * MoveOptions specifies kinematic constraints for an arm motion. All fields
 * are optional ceilings; any combination may be set. Every constraint that
 * is set is respected at every point along the executed trajectory.
 * The limiting constraint may change throughout execution.
 *
 * @generated from message viam.component.arm.v1.MoveOptions
 */
export declare class MoveOptions extends Message<MoveOptions> {
  /**
   * Maximum allowable velocity of an arm joint, in degrees per second.
   * The arm driver will move as fast as possible up to the set value.
   * Ignored when max_vel_degs_per_sec_joints is set.
   *
   * @generated from field: optional double max_vel_degs_per_sec = 1;
   */
  maxVelDegsPerSec?: number;

  /**
   * Maximum allowable acceleration of an arm joint, in degrees per second squared.
   * The arm driver will accelerate as fast as possible up to the set value.
   * ignored when max_acc_degs_per_sec2_joints is set.
   *
   * @generated from field: optional double max_acc_degs_per_sec2 = 2;
   */
  maxAccDegsPerSec2?: number;

  /**
   * Per-joint maximum velocity in degrees per second.
   * The arm driver will move each joint as fast as possible up to its respective set value.
   *
   * @generated from field: repeated double max_vel_degs_per_sec_joints = 3;
   */
  maxVelDegsPerSecJoints: number[];

  /**
   * Per-joint maximum acceleration in degrees per second squared.
   * The arm driver will accelerate each joint as fast as possible up to its respective set value.
   *
   * @generated from field: repeated double max_acc_degs_per_sec2_joints = 4;
   */
  maxAccDegsPerSec2Joints: number[];

  /**
   * Maximum allowable speed of an arm's tool center point in meters per second.
   * The arm driver will move the tool center point as fast as possible up to this set value.
   *
   * @generated from field: optional double max_tcp_speed = 5;
   */
  maxTcpSpeed?: number;

  constructor(data?: PartialMessage<MoveOptions>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.component.arm.v1.MoveOptions";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MoveOptions;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MoveOptions;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MoveOptions;

  static equals(a: MoveOptions | PlainMessage<MoveOptions> | undefined, b: MoveOptions | PlainMessage<MoveOptions> | undefined): boolean;
}

/**
 * @generated from message viam.component.arm.v1.SetManualModeRequest
 */
export declare class SetManualModeRequest extends Message<SetManualModeRequest> {
  /**
   * Name of an arm
   *
   * @generated from field: string name = 1;
   */
  name: string;

  /**
   * True to enter manual mode, false to exit it
   *
   * @generated from field: bool manual_mode = 2;
   */
  manualMode: boolean;

  /**
   * How long to stay in manual mode, in seconds; 0 means no time limit
   *
   * @generated from field: int32 enabled_for = 3;
   */
  enabledFor: number;

  /**
   * Additional arguments to the method
   *
   * @generated from field: google.protobuf.Struct extra = 99;
   */
  extra?: Struct;

  constructor(data?: PartialMessage<SetManualModeRequest>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.component.arm.v1.SetManualModeRequest";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SetManualModeRequest;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SetManualModeRequest;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SetManualModeRequest;

  static equals(a: SetManualModeRequest | PlainMessage<SetManualModeRequest> | undefined, b: SetManualModeRequest | PlainMessage<SetManualModeRequest> | undefined): boolean;
}

/**
 * @generated from message viam.component.arm.v1.SetManualModeResponse
 */
export declare class SetManualModeResponse extends Message<SetManualModeResponse> {
  constructor(data?: PartialMessage<SetManualModeResponse>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.component.arm.v1.SetManualModeResponse";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SetManualModeResponse;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SetManualModeResponse;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SetManualModeResponse;

  static equals(a: SetManualModeResponse | PlainMessage<SetManualModeResponse> | undefined, b: SetManualModeResponse | PlainMessage<SetManualModeResponse> | undefined): boolean;
}

/**
 * @generated from message viam.component.arm.v1.GetManualModeRequest
 */
export declare class GetManualModeRequest extends Message<GetManualModeRequest> {
  /**
   * Name of an arm
   *
   * @generated from field: string name = 1;
   */
  name: string;

  /**
   * Additional arguments to the method
   *
   * @generated from field: google.protobuf.Struct extra = 99;
   */
  extra?: Struct;

  constructor(data?: PartialMessage<GetManualModeRequest>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.component.arm.v1.GetManualModeRequest";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetManualModeRequest;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetManualModeRequest;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetManualModeRequest;

  static equals(a: GetManualModeRequest | PlainMessage<GetManualModeRequest> | undefined, b: GetManualModeRequest | PlainMessage<GetManualModeRequest> | undefined): boolean;
}

/**
 * @generated from message viam.component.arm.v1.GetManualModeResponse
 */
export declare class GetManualModeResponse extends Message<GetManualModeResponse> {
  /**
   * True if the arm is in manual mode
   *
   * @generated from field: bool manual_mode = 1;
   */
  manualMode: boolean;

  constructor(data?: PartialMessage<GetManualModeResponse>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.component.arm.v1.GetManualModeResponse";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetManualModeResponse;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetManualModeResponse;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetManualModeResponse;

  static equals(a: GetManualModeResponse | PlainMessage<GetManualModeResponse> | undefined, b: GetManualModeResponse | PlainMessage<GetManualModeResponse> | undefined): boolean;
}

/**
 * @generated from message viam.component.arm.v1.GetPropertiesRequest
 */
export declare class GetPropertiesRequest extends Message<GetPropertiesRequest> {
  /**
   * Name of an arm
   *
   * @generated from field: string name = 1;
   */
  name: string;

  /**
   * Additional arguments to the method
   *
   * @generated from field: google.protobuf.Struct extra = 99;
   */
  extra?: Struct;

  constructor(data?: PartialMessage<GetPropertiesRequest>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.component.arm.v1.GetPropertiesRequest";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetPropertiesRequest;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetPropertiesRequest;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetPropertiesRequest;

  static equals(a: GetPropertiesRequest | PlainMessage<GetPropertiesRequest> | undefined, b: GetPropertiesRequest | PlainMessage<GetPropertiesRequest> | undefined): boolean;
}

/**
 * @generated from message viam.component.arm.v1.GetPropertiesResponse
 */
export declare class GetPropertiesResponse extends Message<GetPropertiesResponse> {
  /**
   * True if the arm supports software-enabled manual mode
   *
   * @generated from field: bool support_manual_mode = 1;
   */
  supportManualMode: boolean;

  /**
   * True if the arm supports direct cartesian commands (MoveToPosition is implemented)
   *
   * @generated from field: bool support_cartesian_commands = 2;
   */
  supportCartesianCommands: boolean;

  constructor(data?: PartialMessage<GetPropertiesResponse>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.component.arm.v1.GetPropertiesResponse";
  static readonly fields: FieldList;

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetPropertiesResponse;

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetPropertiesResponse;

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetPropertiesResponse;

  static equals(a: GetPropertiesResponse | PlainMessage<GetPropertiesResponse> | undefined, b: GetPropertiesResponse | PlainMessage<GetPropertiesResponse> | undefined): boolean;
}