import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Message, MethodOptions, proto3, Struct, Timestamp, Value } 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 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<ArrayBuffer>;
    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<ArrayBuffer>;
    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<ArrayBuffer>;
    /**
     * 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;
}
/**
 * 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<ArrayBuffer>;
    /**
     * 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;
    /**
     * 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> {
    /**
     * 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;
     */
    format: KinematicsFileFormat;
    /**
     * The byte contents of the file
     *
     * @generated from field: bytes kinematics_data = 2;
     */
    kinematicsData: Uint8Array<ArrayBuffer>;
    /**
     * Map of URDF mesh file paths to mesh data
     *
     * @generated from field: map<string, viam.common.v1.Mesh> meshes_by_urdf_filepath = 3;
     */
    meshesByUrdfFilepath: {
        [key: string]: Mesh;
    };
    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;
}
/**
 * @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: import("@bufbuild/protobuf").Extension<MethodOptions, boolean>;
