// The following is a list of messages that are used across multiple resource subtypes

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

import type { BinaryReadOptions, Extension, FieldList, JsonReadOptions, JsonValue, MethodOptions, PartialMessage, PlainMessage, Struct, Timestamp, Value } from "@bufbuild/protobuf";
import { Message, proto3 } from "@bufbuild/protobuf";

/**
 * @generated from enum viam.common.v1.KinematicsFileFormat
 */
export declare enum KinematicsFileFormat {
  /**
   * @generated from enum value: KINEMATICS_FILE_FORMAT_UNSPECIFIED = 0;
   */
  UNSPECIFIED = 0,

  /**
   * @generated from enum value: KINEMATICS_FILE_FORMAT_SVA = 1;
   */
  SVA = 1,

  /**
   * @generated from enum value: KINEMATICS_FILE_FORMAT_URDF = 2;
   */
  URDF = 2,
}

/**
 * @generated from enum viam.common.v1.JointType
 */
export declare enum JointType {
  /**
   * @generated from enum value: JOINT_TYPE_UNSPECIFIED = 0;
   */
  UNSPECIFIED = 0,

  /**
   * @generated from enum value: JOINT_TYPE_REVOLUTE = 1;
   */
  REVOLUTE = 1,

  /**
   * @generated from enum value: JOINT_TYPE_PRISMATIC = 2;
   */
  PRISMATIC = 2,

  /**
   * Revolute joint with no position bound
   *
   * @generated from enum value: JOINT_TYPE_CONTINUOUS = 3;
   */
  CONTINUOUS = 3,
}

/**
 * @generated from message viam.common.v1.ResourceName
 */
export declare class ResourceName extends Message<ResourceName> {
  /**
   * @generated from field: string namespace = 1;
   */
  namespace: string;

  /**
   * @generated from field: string type = 2;
   */
  type: string;

  /**
   * @generated from field: string subtype = 3;
   */
  subtype: string;

  /**
   * @generated from field: string name = 4;
   */
  name: string;

  constructor(data?: PartialMessage<ResourceName>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.common.v1.ResourceName";
  static readonly fields: FieldList;

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

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

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

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

/**
 * Pose is a combination of location and orientation.
 * Location is expressed as distance which is represented by x , y, z coordinates. Orientation is expressed as an orientation vector which
 * is represented by o_x, o_y, o_z and theta. The o_x, o_y, o_z coordinates represent the point on the cartesian unit sphere that the end of
 * the arm is pointing to (with the origin as reference). That unit vector forms an axis around which theta rotates. This means that
 * incrementing / decrementing theta will perform an inline rotation of the end effector.
 * Theta is defined as rotation between two planes: the first being defined by the origin, the point (0,0,1), and the rx, ry, rz point, and the
 * second being defined by the origin, the rx, ry, rz point and the local Z axis. Therefore, if theta is kept at zero as the north/south pole
 * is circled, the Roll will correct itself to remain in-line. 
 *
 * @generated from message viam.common.v1.Pose
 */
export declare class Pose extends Message<Pose> {
  /**
   * millimeters from the origin
   *
   * @generated from field: double x = 1;
   */
  x: number;

  /**
   * millimeters from the origin
   *
   * @generated from field: double y = 2;
   */
  y: number;

  /**
   * millimeters from the origin
   *
   * @generated from field: double z = 3;
   */
  z: number;

  /**
   * z component of a vector defining axis of rotation
   *
   * @generated from field: double o_x = 4;
   */
  oX: number;

  /**
   * x component of a vector defining axis of rotation
   *
   * @generated from field: double o_y = 5;
   */
  oY: number;

  /**
   * y component of a vector defining axis of rotation
   *
   * @generated from field: double o_z = 6;
   */
  oZ: number;

  /**
   * degrees
   *
   * @generated from field: double theta = 7;
   */
  theta: number;

  constructor(data?: PartialMessage<Pose>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.common.v1.Pose";
  static readonly fields: FieldList;

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

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

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

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

/**
 * @generated from message viam.common.v1.Orientation
 */
export declare class Orientation extends Message<Orientation> {
  /**
   * x component of a vector defining axis of rotation
   *
   * @generated from field: double o_x = 1;
   */
  oX: number;

  /**
   * y component of a vector defining axis of rotation
   *
   * @generated from field: double o_y = 2;
   */
  oY: number;

  /**
   * z component of a vector defining axis of rotation
   *
   * @generated from field: double o_z = 3;
   */
  oZ: number;

  /**
   * degrees
   *
   * @generated from field: double theta = 4;
   */
  theta: number;

  constructor(data?: PartialMessage<Orientation>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.common.v1.Orientation";
  static readonly fields: FieldList;

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

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

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

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

/**
 * @generated from message viam.common.v1.PoseCloud
 */
export declare class PoseCloud extends Message<PoseCloud> {
  /**
   * @generated from field: double x = 1;
   */
  x: number;

  /**
   * @generated from field: double y = 2;
   */
  y: number;

  /**
   * @generated from field: double z = 3;
   */
  z: number;

  /**
   * @generated from field: double o_x = 4;
   */
  oX: number;

  /**
   * @generated from field: double o_y = 5;
   */
  oY: number;

  /**
   * @generated from field: double o_z = 6;
   */
  oZ: number;

  /**
   * @generated from field: double theta = 7;
   */
  theta: number;

  constructor(data?: PartialMessage<PoseCloud>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.common.v1.PoseCloud";
  static readonly fields: FieldList;

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

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

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

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

/**
 * PoseInFrame contains a pose and the reference frame in which it was observed
 *
 * @generated from message viam.common.v1.PoseInFrame
 */
export declare class PoseInFrame extends Message<PoseInFrame> {
  /**
   * @generated from field: string reference_frame = 1;
   */
  referenceFrame: string;

  /**
   * @generated from field: viam.common.v1.Pose pose = 2;
   */
  pose?: Pose;

  /**
   * @generated from field: optional viam.common.v1.PoseCloud goal_cloud = 3;
   */
  goalCloud?: PoseCloud;

  constructor(data?: PartialMessage<PoseInFrame>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.common.v1.PoseInFrame";
  static readonly fields: FieldList;

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

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

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

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

/**
 * @generated from message viam.common.v1.Vector3
 */
export declare class Vector3 extends Message<Vector3> {
  /**
   * @generated from field: double x = 1;
   */
  x: number;

  /**
   * @generated from field: double y = 2;
   */
  y: number;

  /**
   * @generated from field: double z = 3;
   */
  z: number;

  constructor(data?: PartialMessage<Vector3>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.common.v1.Vector3";
  static readonly fields: FieldList;

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

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

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

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

/**
 * @generated from message viam.common.v1.Sphere
 */
export declare class Sphere extends Message<Sphere> {
  /**
   * @generated from field: double radius_mm = 1;
   */
  radiusMm: number;

  constructor(data?: PartialMessage<Sphere>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.common.v1.Sphere";
  static readonly fields: FieldList;

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

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

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

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

/**
 * @generated from message viam.common.v1.Capsule
 */
export declare class Capsule extends Message<Capsule> {
  /**
   * @generated from field: double radius_mm = 1;
   */
  radiusMm: number;

  /**
   * @generated from field: double length_mm = 2;
   */
  lengthMm: number;

  constructor(data?: PartialMessage<Capsule>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.common.v1.Capsule";
  static readonly fields: FieldList;

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

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

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

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

/**
 * RectangularPrism contains a Vector3 field corresponding to the X, Y, Z dimensions of the prism in mms
 * These dimensions are with respect to the referenceframe in which the RectangularPrism is defined
 *
 * @generated from message viam.common.v1.RectangularPrism
 */
export declare class RectangularPrism extends Message<RectangularPrism> {
  /**
   * @generated from field: viam.common.v1.Vector3 dims_mm = 1;
   */
  dimsMm?: Vector3;

  constructor(data?: PartialMessage<RectangularPrism>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.common.v1.RectangularPrism";
  static readonly fields: FieldList;

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

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

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

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

/**
 * @generated from message viam.common.v1.Mesh
 */
export declare class Mesh extends Message<Mesh> {
  /**
   * Content type of mesh (e.g. ply)
   *
   * @generated from field: string content_type = 1;
   */
  contentType: string;

  /**
   * Contents of mesh data in binary form defined by content_type
   *
   * @generated from field: bytes mesh = 2;
   */
  mesh: Uint8Array;

  /**
   * Path the mesh was loaded from, relative to the kinematics file. Informational on the wire.
   *
   * @generated from field: optional string original_file_source_path_diagnostic = 3;
   */
  originalFileSourcePathDiagnostic?: string;

  constructor(data?: PartialMessage<Mesh>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.common.v1.Mesh";
  static readonly fields: FieldList;

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

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

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

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

/**
 * @generated from message viam.common.v1.PointCloud
 */
export declare class PointCloud extends Message<PointCloud> {
  /**
   * @generated from field: bytes point_cloud = 1;
   */
  pointCloud: Uint8Array;

  constructor(data?: PartialMessage<PointCloud>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.common.v1.PointCloud";
  static readonly fields: FieldList;

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

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

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

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

/**
 * Geometry contains the dimensions of a given geometry and the pose of its center. The geometry is one of either a sphere or a box.
 *
 * @generated from message viam.common.v1.Geometry
 */
export declare class Geometry extends Message<Geometry> {
  /**
   * Pose of a geometries center point
   *
   * @generated from field: viam.common.v1.Pose center = 1;
   */
  center?: Pose;

  /**
   * Dimensions of a given geometry. This can be one of several types
   *
   * @generated from oneof viam.common.v1.Geometry.geometry_type
   */
  geometryType: {
    /**
     * @generated from field: viam.common.v1.Sphere sphere = 2;
     */
    value: Sphere;
    case: "sphere";
  } | {
    /**
     * @generated from field: viam.common.v1.RectangularPrism box = 3;
     */
    value: RectangularPrism;
    case: "box";
  } | {
    /**
     * @generated from field: viam.common.v1.Capsule capsule = 5;
     */
    value: Capsule;
    case: "capsule";
  } | {
    /**
     * @generated from field: viam.common.v1.Mesh mesh = 6;
     */
    value: Mesh;
    case: "mesh";
  } | {
    /**
     * @generated from field: viam.common.v1.PointCloud pointcloud = 7;
     */
    value: PointCloud;
    case: "pointcloud";
  } | { case: undefined; value?: undefined };

  /**
   * Label of the geometry. If none supplied, will be an empty string.
   *
   * @generated from field: string label = 4;
   */
  label: string;

  constructor(data?: PartialMessage<Geometry>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.common.v1.Geometry";
  static readonly fields: FieldList;

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

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

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

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

/**
 * GeometriesinFrame contains the dimensions of a given geometry, pose of its center point, and the reference frame by which it was
 * observed.
 *
 * @generated from message viam.common.v1.GeometriesInFrame
 */
export declare class GeometriesInFrame extends Message<GeometriesInFrame> {
  /**
   * Reference frame of the observer of the geometry
   *
   * @generated from field: string reference_frame = 1;
   */
  referenceFrame: string;

  /**
   * Dimensional type
   *
   * @generated from field: repeated viam.common.v1.Geometry geometries = 2;
   */
  geometries: Geometry[];

  constructor(data?: PartialMessage<GeometriesInFrame>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.common.v1.GeometriesInFrame";
  static readonly fields: FieldList;

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

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

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

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

/**
 * PointCloudObject contains an image in bytes with point cloud data of all of the objects captured by a given observer as well as a
 * repeated list of geometries which respresents the center point and geometry of each of the objects within the point cloud
 *
 * @generated from message viam.common.v1.PointCloudObject
 */
export declare class PointCloudObject extends Message<PointCloudObject> {
  /**
   * image frame expressed in bytes
   *
   * @generated from field: bytes point_cloud = 1;
   */
  pointCloud: Uint8Array;

  /**
   * volume of a given geometry
   *
   * @generated from field: viam.common.v1.GeometriesInFrame geometries = 2;
   */
  geometries?: GeometriesInFrame;

  constructor(data?: PartialMessage<PointCloudObject>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.common.v1.PointCloudObject";
  static readonly fields: FieldList;

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

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

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

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

/**
 * @generated from message viam.common.v1.GeoPoint
 */
export declare class GeoPoint extends Message<GeoPoint> {
  /**
   * @generated from field: double latitude = 1;
   */
  latitude: number;

  /**
   * @generated from field: double longitude = 2;
   */
  longitude: number;

  constructor(data?: PartialMessage<GeoPoint>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.common.v1.GeoPoint";
  static readonly fields: FieldList;

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

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

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

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

/**
 * GeoPose is a GPS position and orientation, optionally with altitude.
 *
 * Orientation is expressed in the east-north-up tangent frame at location:
 * +X east, +Y north, +Z up. Viam base axes are +X right, +Y forward, and +Z up,
 * so the identity orientation (o_x, o_y, o_z, theta) = (0, 0, 1, 0) is level and
 * faces north: forward is north and right is east.
 *
 * The same rotation as an orientation vector is Viam's Tait-Bryan Euler sequence,
 * intrinsic z-y'-x'' (yaw, then pitch, then roll), in degrees:
 *   - yaw: right-handed rotation about local up (+Z). Zero faces north. Positive
 *     yaw is counterclockwise viewed from above, so a compass heading in degrees
 *     clockwise from north is the negation of yaw.
 *   - pitch: right-handed rotation about the base's forward axis (+Y).
 *   - roll: right-handed rotation about the base's right axis (+X). With pitch 0,
 *     positive roll raises the forward axis; that angle is the elevation of
 *     forward above the local horizon.
 *
 * Exactly one of heading or orientation_vector is set. heading is only the
 * compass yaw of a level pose (pitch 0, roll 0). It is not added to
 * orientation_vector.
 *
 * @generated from message viam.common.v1.GeoPose
 */
export declare class GeoPose extends Message<GeoPose> {
  /**
   * Latitude and longitude in degrees
   *
   * @generated from field: viam.common.v1.GeoPoint location = 1;
   */
  location?: GeoPoint;

  /**
   * Optional altitude in meters
   *
   * @generated from field: optional double altitude = 3;
   */
  altitude?: number;

  /**
   * @generated from oneof viam.common.v1.GeoPose.orientation
   */
  orientation: {
    /**
     * Compass heading in degrees, clockwise from north. Level pose: pitch 0, roll 0.
     *
     * @generated from field: double heading = 2;
     */
    value: number;
    case: "heading";
  } | {
    /**
     * Full orientation in the east-north-up tangent frame at location.
     * o_x, o_y, o_z, theta in degrees, same orientation vector as Pose.
     *
     * @generated from field: viam.common.v1.Orientation orientation_vector = 4;
     */
    value: Orientation;
    case: "orientationVector";
  } | { case: undefined; value?: undefined };

  constructor(data?: PartialMessage<GeoPose>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.common.v1.GeoPose";
  static readonly fields: FieldList;

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

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

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

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

/**
 * GeoGeometry contains information describing Geometry(s) that is located at a GeoPoint
 *
 * @generated from message viam.common.v1.GeoGeometry
 */
export declare class GeoGeometry extends Message<GeoGeometry> {
  /**
   * Location of the geometry
   *
   * @generated from field: viam.common.v1.GeoPoint location = 1;
   */
  location?: GeoPoint;

  /**
   * Geometries associated with the location, where embedded Pose data is with respect to the specified location
   *
   * @generated from field: repeated viam.common.v1.Geometry geometries = 2;
   */
  geometries: Geometry[];

  constructor(data?: PartialMessage<GeoGeometry>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.common.v1.GeoGeometry";
  static readonly fields: FieldList;

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

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

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

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

/**
 * Transform contains a pose and two reference frames. The first reference frame is the starting reference frame, and the second reference
 * frame is the observer reference frame. The second reference frame has a pose which represents the pose of an object in the first
 * reference frame as observed within the second reference frame.
 *
 * @generated from message viam.common.v1.Transform
 */
export declare class Transform extends Message<Transform> {
  /**
   * the name of a given reference frame
   *
   * @generated from field: string reference_frame = 1;
   */
  referenceFrame: string;

  /**
   * the pose of the above reference frame with respect to a different observer reference frame
   *
   * @generated from field: viam.common.v1.PoseInFrame pose_in_observer_frame = 2;
   */
  poseInObserverFrame?: PoseInFrame;

  /**
   * @generated from field: optional viam.common.v1.Geometry physical_object = 3;
   */
  physicalObject?: Geometry;

  /**
   * The UUID of the transform
   *
   * @generated from field: bytes uuid = 4;
   */
  uuid: Uint8Array;

  /**
   * Can hold information like color, opacity, points colors, collision_allowed, etc...
   *
   * @generated from field: optional google.protobuf.Struct metadata = 5;
   */
  metadata?: Struct;

  constructor(data?: PartialMessage<Transform>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.common.v1.Transform";
  static readonly fields: FieldList;

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

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

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

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

/**
 * WorldState contains information about the physical environment around a given robot. All of the fields within this message are optional,
 * they can include information about the physical dimensions of an obstacle, the freespace of a robot, and any desired transforms between a
 * given reference frame and a new target reference frame.
 *
 * @generated from message viam.common.v1.WorldState
 */
export declare class WorldState extends Message<WorldState> {
  /**
   * a list of obstacles expressed as a geometry and the reference frame in which it was observed; this field is optional
   *
   * @generated from field: repeated viam.common.v1.GeometriesInFrame obstacles = 1;
   */
  obstacles: GeometriesInFrame[];

  /**
   * a list of Transforms, optionally with geometries. Used as supplemental transforms to transform a pose from one reference frame to
   * another, or to attach moving geometries to the frame system. This field is optional
   *
   * @generated from field: repeated viam.common.v1.Transform transforms = 3;
   */
  transforms: Transform[];

  constructor(data?: PartialMessage<WorldState>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.common.v1.WorldState";
  static readonly fields: FieldList;

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

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

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

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

/**
 * ActuatorStatus is a generic status for resources that only need to return actuator status.
 *
 * @generated from message viam.common.v1.ActuatorStatus
 */
export declare class ActuatorStatus extends Message<ActuatorStatus> {
  /**
   * @generated from field: bool is_moving = 1;
   */
  isMoving: boolean;

  constructor(data?: PartialMessage<ActuatorStatus>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.common.v1.ActuatorStatus";
  static readonly fields: FieldList;

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

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

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

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

/**
 * @generated from message viam.common.v1.ResponseMetadata
 */
export declare class ResponseMetadata extends Message<ResponseMetadata> {
  /**
   * captured_at is the time at which the resource as close as physically possible, captured
   * the data in the response.
   * Note: If correlating between other resources, be sure that the means
   * of measuring the capture are similar enough such that comparison can be made between them.
   *
   * @generated from field: optional google.protobuf.Timestamp captured_at = 1;
   */
  capturedAt?: Timestamp;

  constructor(data?: PartialMessage<ResponseMetadata>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.common.v1.ResponseMetadata";
  static readonly fields: FieldList;

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

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

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

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

/**
 * DoCommandRequest represents a generic DoCommand input
 *
 * @generated from message viam.common.v1.DoCommandRequest
 */
export declare class DoCommandRequest extends Message<DoCommandRequest> {
  /**
   * @generated from field: string name = 1;
   */
  name: string;

  /**
   * @generated from field: google.protobuf.Struct command = 2;
   */
  command?: Struct;

  constructor(data?: PartialMessage<DoCommandRequest>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.common.v1.DoCommandRequest";
  static readonly fields: FieldList;

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

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

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

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

/**
 * DoCommandResponse represents a generic DoCommand output
 *
 * @generated from message viam.common.v1.DoCommandResponse
 */
export declare class DoCommandResponse extends Message<DoCommandResponse> {
  /**
   * @generated from field: google.protobuf.Struct result = 1;
   */
  result?: Struct;

  constructor(data?: PartialMessage<DoCommandResponse>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.common.v1.DoCommandResponse";
  static readonly fields: FieldList;

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

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

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

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

/**
 * GetStatusRequest represents a generic GetStatus input
 *
 * @generated from message viam.common.v1.GetStatusRequest
 */
export declare class GetStatusRequest extends Message<GetStatusRequest> {
  /**
   * @generated from field: string name = 1;
   */
  name: string;

  constructor(data?: PartialMessage<GetStatusRequest>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.common.v1.GetStatusRequest";
  static readonly fields: FieldList;

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

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

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

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

/**
 * GetStatusResponse represents a generic GetStatus output
 *
 * @generated from message viam.common.v1.GetStatusResponse
 */
export declare class GetStatusResponse extends Message<GetStatusResponse> {
  /**
   * @generated from field: google.protobuf.Struct result = 1;
   */
  result?: Struct;

  constructor(data?: PartialMessage<GetStatusResponse>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.common.v1.GetStatusResponse";
  static readonly fields: FieldList;

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

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

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

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

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

  /**
   * Include collision mesh bytes in the response. Otherwise meshes carry only their path.
   *
   * @generated from field: bool include_collision_meshes = 2;
   */
  includeCollisionMeshes: boolean;

  /**
   * Include visual mesh bytes in the response
   *
   * @generated from field: bool include_visual_meshes = 3;
   */
  includeVisualMeshes: boolean;

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

  constructor(data?: PartialMessage<GetKinematicsRequest>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.common.v1.GetKinematicsRequest";
  static readonly fields: FieldList;

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

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

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

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

/**
 * @generated from message viam.common.v1.GetKinematicsResponse
 */
export declare class GetKinematicsResponse extends Message<GetKinematicsResponse> {
  /**
   * Deprecated: use model. The kinematics of the component, in either URDF format or in Viam’s kinematic parameter format (spatial vector algebra)
   * https://docs.viam.com/internals/kinematic-chain-config/#kinematic-parameters
   *
   * @generated from field: viam.common.v1.KinematicsFileFormat format = 1 [deprecated = true];
   * @deprecated
   */
  format: KinematicsFileFormat;

  /**
   * Deprecated: use model. The byte contents of the file
   *
   * @generated from field: bytes kinematics_data = 2 [deprecated = true];
   * @deprecated
   */
  kinematicsData: Uint8Array;

  /**
   * Deprecated: use model. Map of URDF mesh file paths to mesh data
   *
   * @generated from field: map<string, viam.common.v1.Mesh> meshes_by_urdf_filepath = 3 [deprecated = true];
   * @deprecated
   */
  meshesByUrdfFilepath: { [key: string]: Mesh };

  /**
   * The kinematic model of the component
   *
   * @generated from field: viam.common.v1.KinematicModel model = 4;
   */
  model?: KinematicModel;

  constructor(data?: PartialMessage<GetKinematicsResponse>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.common.v1.GetKinematicsResponse";
  static readonly fields: FieldList;

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

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

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

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

/**
 * KinematicModel describes a component's kinematics as a tree of links and joints.
 * Its proto JSON encoding is also the on-disk kinematics file format.
 *
 * @generated from message viam.common.v1.KinematicModel
 */
export declare class KinematicModel extends Message<KinematicModel> {
  /**
   * Set to the resource name by the SDK when served
   *
   * @generated from field: string name = 1;
   */
  name: string;

  /**
   * @generated from field: repeated viam.common.v1.KinematicLink links = 2;
   */
  links: KinematicLink[];

  /**
   * @generated from field: repeated viam.common.v1.KinematicJoint joints = 3;
   */
  joints: KinematicJoint[];

  /**
   * Frames whose poses the model reports
   *
   * @generated from field: repeated string output_frames = 4;
   */
  outputFrames: string[];

  /**
   * @generated from field: viam.common.v1.KinematicProperties properties = 5;
   */
  properties?: KinematicProperties;

  constructor(data?: PartialMessage<KinematicModel>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.common.v1.KinematicModel";
  static readonly fields: FieldList;

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

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

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

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

/**
 * @generated from message viam.common.v1.KinematicLink
 */
export declare class KinematicLink extends Message<KinematicLink> {
  /**
   * @generated from field: string id = 1;
   */
  id: string;

  /**
   * Parent link or joint id, empty for the root
   *
   * @generated from field: string parent = 2;
   */
  parent: string;

  /**
   * Pose relative to the parent
   *
   * @generated from field: viam.common.v1.LinkPose pose = 3;
   */
  pose?: LinkPose;

  /**
   * Collision geometries, meshes must be stl or ply
   *
   * @generated from field: repeated viam.common.v1.Geometry collision = 4;
   */
  collision: Geometry[];

  /**
   * Display geometries, not used for collision checking
   *
   * @generated from field: repeated viam.common.v1.Geometry visual = 5;
   */
  visual: Geometry[];

  constructor(data?: PartialMessage<KinematicLink>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.common.v1.KinematicLink";
  static readonly fields: FieldList;

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

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

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

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

/**
 * LinkPose is a translation in mm and an orientation in degrees, identity when absent
 *
 * @generated from message viam.common.v1.LinkPose
 */
export declare class LinkPose extends Message<LinkPose> {
  /**
   * @generated from field: viam.common.v1.Vector3 translation = 1;
   */
  translation?: Vector3;

  /**
   * @generated from oneof viam.common.v1.LinkPose.orientation
   */
  orientation: {
    /**
     * @generated from field: viam.common.v1.Quaternion quaternion = 2;
     */
    value: Quaternion;
    case: "quaternion";
  } | {
    /**
     * theta in degrees
     *
     * @generated from field: viam.common.v1.Orientation orientation_vector = 3;
     */
    value: Orientation;
    case: "orientationVector";
  } | {
    /**
     * @generated from field: viam.common.v1.EulerAngles euler_angles = 4;
     */
    value: EulerAngles;
    case: "eulerAngles";
  } | {
    /**
     * @generated from field: viam.common.v1.AxisAngles axis_angles = 5;
     */
    value: AxisAngles;
    case: "axisAngles";
  } | { case: undefined; value?: undefined };

  constructor(data?: PartialMessage<LinkPose>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.common.v1.LinkPose";
  static readonly fields: FieldList;

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

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

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

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

/**
 * @generated from message viam.common.v1.Quaternion
 */
export declare class Quaternion extends Message<Quaternion> {
  /**
   * @generated from field: double w = 1;
   */
  w: number;

  /**
   * @generated from field: double x = 2;
   */
  x: number;

  /**
   * @generated from field: double y = 3;
   */
  y: number;

  /**
   * @generated from field: double z = 4;
   */
  z: number;

  constructor(data?: PartialMessage<Quaternion>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.common.v1.Quaternion";
  static readonly fields: FieldList;

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

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

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

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

/**
 * Euler angles in degrees
 *
 * @generated from message viam.common.v1.EulerAngles
 */
export declare class EulerAngles extends Message<EulerAngles> {
  /**
   * @generated from field: double roll = 1;
   */
  roll: number;

  /**
   * @generated from field: double pitch = 2;
   */
  pitch: number;

  /**
   * @generated from field: double yaw = 3;
   */
  yaw: number;

  constructor(data?: PartialMessage<EulerAngles>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.common.v1.EulerAngles";
  static readonly fields: FieldList;

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

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

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

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

/**
 * Rotation axis and an angle theta in degrees
 *
 * @generated from message viam.common.v1.AxisAngles
 */
export declare class AxisAngles extends Message<AxisAngles> {
  /**
   * @generated from field: double rx = 1;
   */
  rx: number;

  /**
   * @generated from field: double ry = 2;
   */
  ry: number;

  /**
   * @generated from field: double rz = 3;
   */
  rz: number;

  /**
   * @generated from field: double theta = 4;
   */
  theta: number;

  constructor(data?: PartialMessage<AxisAngles>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.common.v1.AxisAngles";
  static readonly fields: FieldList;

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

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

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

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

/**
 * @generated from message viam.common.v1.KinematicJoint
 */
export declare class KinematicJoint extends Message<KinematicJoint> {
  /**
   * @generated from field: string id = 1;
   */
  id: string;

  /**
   * Parent link id
   *
   * @generated from field: string parent = 2;
   */
  parent: string;

  /**
   * @generated from field: viam.common.v1.JointType type = 3;
   */
  type: JointType;

  /**
   * @generated from field: viam.common.v1.Vector3 axis = 4;
   */
  axis?: Vector3;

  /**
   * Effective limits the component serves
   *
   * @generated from field: viam.common.v1.JointLimits limits = 5;
   */
  limits?: JointLimits;

  /**
   * @generated from field: viam.common.v1.MimicJoint mimic = 6;
   */
  mimic?: MimicJoint;

  /**
   * Only meaningful for prismatic joints
   *
   * @generated from field: viam.common.v1.Geometry geometry = 7;
   */
  geometry?: Geometry;

  constructor(data?: PartialMessage<KinematicJoint>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.common.v1.KinematicJoint";
  static readonly fields: FieldList;

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

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

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

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

/**
 * Degrees, deg/s and deg/s^2 for revolute joints, mm, mm/s and mm/s^2 for prismatic. Absent means unbounded.
 *
 * @generated from message viam.common.v1.JointLimits
 */
export declare class JointLimits extends Message<JointLimits> {
  /**
   * @generated from field: optional double min = 1;
   */
  min?: number;

  /**
   * @generated from field: optional double max = 2;
   */
  max?: number;

  /**
   * @generated from field: optional double max_velocity = 3;
   */
  maxVelocity?: number;

  /**
   * @generated from field: optional double max_acceleration = 4;
   */
  maxAcceleration?: number;

  constructor(data?: PartialMessage<JointLimits>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.common.v1.JointLimits";
  static readonly fields: FieldList;

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

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

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

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

/**
 * Position is multiplier * position of joint + offset
 *
 * @generated from message viam.common.v1.MimicJoint
 */
export declare class MimicJoint extends Message<MimicJoint> {
  /**
   * @generated from field: string joint = 1;
   */
  joint: string;

  /**
   * @generated from field: double multiplier = 2;
   */
  multiplier: number;

  /**
   * @generated from field: double offset = 3;
   */
  offset: number;

  constructor(data?: PartialMessage<MimicJoint>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.common.v1.MimicJoint";
  static readonly fields: FieldList;

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

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

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

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

/**
 * Properties of the component as a whole
 *
 * @generated from message viam.common.v1.KinematicProperties
 */
export declare class KinematicProperties extends Message<KinematicProperties> {
  /**
   * Rate the component expects to be driven at
   *
   * @generated from field: optional double operating_freq_hz = 1;
   */
  operatingFreqHz?: number;

  /**
   * Maximum linear speed of the tool center point
   *
   * @generated from field: optional double max_linear_tcp_speed_mm_per_sec = 2;
   */
  maxLinearTcpSpeedMmPerSec?: number;

  constructor(data?: PartialMessage<KinematicProperties>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.common.v1.KinematicProperties";
  static readonly fields: FieldList;

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

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

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

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

/**
 * @generated from message viam.common.v1.GetGeometriesRequest
 */
export declare class GetGeometriesRequest extends Message<GetGeometriesRequest> {
  /**
   * The component name
   *
   * @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<GetGeometriesRequest>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.common.v1.GetGeometriesRequest";
  static readonly fields: FieldList;

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

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

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

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

/**
 * @generated from message viam.common.v1.GetGeometriesResponse
 */
export declare class GetGeometriesResponse extends Message<GetGeometriesResponse> {
  /**
   * All geometries associated with the component, in their current configuration, in the frame of that component.
   *
   * @generated from field: repeated viam.common.v1.Geometry geometries = 1;
   */
  geometries: Geometry[];

  constructor(data?: PartialMessage<GetGeometriesResponse>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.common.v1.GetGeometriesResponse";
  static readonly fields: FieldList;

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

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

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

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

/**
 * @generated from message viam.common.v1.Get3DModelsRequest
 */
export declare class Get3DModelsRequest extends Message<Get3DModelsRequest> {
  /**
   * The component name
   *
   * @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<Get3DModelsRequest>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.common.v1.Get3DModelsRequest";
  static readonly fields: FieldList;

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

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

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

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

/**
 * @generated from message viam.common.v1.Get3DModelsResponse
 */
export declare class Get3DModelsResponse extends Message<Get3DModelsResponse> {
  /**
   * the 3D models associated with the component
   *
   * @generated from field: map<string, viam.common.v1.Mesh> models = 1;
   */
  models: { [key: string]: Mesh };

  constructor(data?: PartialMessage<Get3DModelsResponse>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.common.v1.Get3DModelsResponse";
  static readonly fields: FieldList;

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

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

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

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

/**
 * @generated from message viam.common.v1.GetWorldPoseResponse
 */
export declare class GetWorldPoseResponse extends Message<GetWorldPoseResponse> {
  /**
   * Pose of the component in the world reference frame
   *
   * @generated from field: viam.common.v1.Pose pose = 1;
   */
  pose?: Pose;

  constructor(data?: PartialMessage<GetWorldPoseResponse>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.common.v1.GetWorldPoseResponse";
  static readonly fields: FieldList;

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

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

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

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

/**
 * @generated from message viam.common.v1.GetReadingsRequest
 */
export declare class GetReadingsRequest extends Message<GetReadingsRequest> {
  /**
   * Name of a sensor
   *
   * @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<GetReadingsRequest>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.common.v1.GetReadingsRequest";
  static readonly fields: FieldList;

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

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

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

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

/**
 * @generated from message viam.common.v1.GetReadingsResponse
 */
export declare class GetReadingsResponse extends Message<GetReadingsResponse> {
  /**
   * @generated from field: map<string, google.protobuf.Value> readings = 1;
   */
  readings: { [key: string]: Value };

  constructor(data?: PartialMessage<GetReadingsResponse>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.common.v1.GetReadingsResponse";
  static readonly fields: FieldList;

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

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

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

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

/**
 * @generated from message viam.common.v1.LogEntry
 */
export declare class LogEntry extends Message<LogEntry> {
  /**
   * @generated from field: string host = 1;
   */
  host: string;

  /**
   * @generated from field: string level = 2;
   */
  level: string;

  /**
   * @generated from field: google.protobuf.Timestamp time = 3;
   */
  time?: Timestamp;

  /**
   * @generated from field: string logger_name = 4;
   */
  loggerName: string;

  /**
   * @generated from field: string message = 5;
   */
  message: string;

  /**
   * @generated from field: google.protobuf.Struct caller = 6;
   */
  caller?: Struct;

  /**
   * @generated from field: string stack = 7;
   */
  stack: string;

  /**
   * @generated from field: repeated google.protobuf.Struct fields = 8;
   */
  fields: Struct[];

  constructor(data?: PartialMessage<LogEntry>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.common.v1.LogEntry";
  static readonly fields: FieldList;

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

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

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

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

/**
 * Information about an audio stream or device.
 *
 * @generated from message viam.common.v1.AudioInfo
 */
export declare class AudioInfo extends Message<AudioInfo> {
  /**
   * Audio codec used for the stream or device (e.g., "pcm16", "pcm32float", "mp3")
   *
   * @generated from field: string codec = 1;
   */
  codec: string;

  /**
   * Sample rate of the audio in Hz
   *
   * @generated from field: int32 sample_rate_hz = 2;
   */
  sampleRateHz: number;

  /**
   * Number of audio channels in the recording or playback
   *
   * @generated from field: int32 num_channels = 3;
   */
  numChannels: number;

  constructor(data?: PartialMessage<AudioInfo>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.common.v1.AudioInfo";
  static readonly fields: FieldList;

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

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

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

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

/**
 * Shared properties for AudioIn and AudioOut components.
 *
 * @generated from message viam.common.v1.GetPropertiesRequest
 */
export declare class GetPropertiesRequest extends Message<GetPropertiesRequest> {
  /**
   * @generated from field: string name = 1;
   */
  name: string;

  /**
   * @generated from field: google.protobuf.Struct extra = 99;
   */
  extra?: Struct;

  constructor(data?: PartialMessage<GetPropertiesRequest>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.common.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.common.v1.GetPropertiesResponse
 */
export declare class GetPropertiesResponse extends Message<GetPropertiesResponse> {
  /**
   * List of audio codecs supported by the system (e.g., "mp3", "pcm16", "pcm32float")
   *
   * @generated from field: repeated string supported_codecs = 1;
   */
  supportedCodecs: string[];

  /**
   * current sample rate in Hz
   *
   * @generated from field: int32 sample_rate_hz = 2;
   */
  sampleRateHz: number;

  /**
   * Maximum number of audio channels supported (e.g., 1 for mono, 2 for stereo)
   *
   * @generated from field: int32 num_channels = 3;
   */
  numChannels: number;

  constructor(data?: PartialMessage<GetPropertiesResponse>);

  static readonly runtime: typeof proto3;
  static readonly typeName = "viam.common.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;
}

/**
 * safety_heartbeat_monitored is used on methods to signify that if a session is in use
 * and the session was the last to call this method, the resource associated with the
 * method will be stopped.
 *
 * @generated from extension: optional bool safety_heartbeat_monitored = 84260;
 */
export declare const safety_heartbeat_monitored: Extension<MethodOptions, boolean>;