@projectqai/proto 0.0.24 → 0.0.25

package/dist/world_pb.d.ts

@@ -176,10 +176,25 @@ export declare type Entity = Message<"world.Entity"> & {
    */
   localShape?: LocalShapeComponent;
 
+  /**
+   * @generated from field: optional world.PoseComponent pose = 38;
+   */
+  pose?: PoseComponent;
+
+  /**
+   * @generated from field: optional world.TaskExecutionComponent task_execution = 41;
+   */
+  taskExecution?: TaskExecutionComponent;
+
   /**
    * @generated from field: optional world.InteractivityComponent interactivity = 60;
    */
   interactivity?: InteractivityComponent;
+
+  /**
+   * @generated from field: optional world.TargetPoseComponent target_pose = 62;
+   */
+  targetPose?: TargetPoseComponent;
 };
 
 /**
@@ -349,9 +364,9 @@ export declare type InteractivityComponent = Message<"world.InteractivityCompone
 export declare const InteractivityComponentSchema: GenMessage<InteractivityComponent>;
 
 /**
- * @generated from message world.Camera
+ * @generated from message world.MediaStream
  */
-export declare type Camera = Message<"world.Camera"> & {
+export declare type MediaStream = Message<"world.MediaStream"> & {
   /**
    * @generated from field: string label = 1;
    */
@@ -363,46 +378,102 @@ export declare type Camera = Message<"world.Camera"> & {
   url: string;
 
   /**
-   * @generated from field: world.CameraProtocol protocol = 3;
+   * @generated from field: world.MediaStreamProtocol protocol = 3;
    */
-  protocol: CameraProtocol;
+  protocol: MediaStreamProtocol;
 
   /**
-   * horizontal field of view in degrees
+   * stream role (main, sub, snapshot)
    *
-   * @generated from field: optional double fov = 4;
+   * @generated from field: world.MediaStreamRole role = 9;
    */
-  fov?: number;
+  role: MediaStreamRole;
 
   /**
-   * minimum detection range in meters (blind zone)
+   * video codec, e.g. "H264", "H265"
    *
-   * @generated from field: optional double range_min = 5;
+   * @generated from field: string codec = 10;
    */
-  rangeMin?: number;
+  codec: string;
 
   /**
-   * maximum detection range in meters
+   * resolution width in pixels
    *
-   * @generated from field: optional double range_max = 6;
+   * @generated from field: optional int32 width = 11;
    */
-  rangeMax?: number;
+  width?: number;
+
+  /**
+   * resolution height in pixels
+   *
+   * @generated from field: optional int32 height = 12;
+   */
+  height?: number;
 };
 
 /**
- * Describes the message world.Camera.
- * Use `create(CameraSchema)` to create a new message.
+ * Describes the message world.MediaStream.
+ * Use `create(MediaStreamSchema)` to create a new message.
  */
-export declare const CameraSchema: GenMessage<Camera>;
+export declare const MediaStreamSchema: GenMessage<MediaStream>;
 
 /**
  * @generated from message world.CameraComponent
  */
 export declare type CameraComponent = Message<"world.CameraComponent"> & {
   /**
-   * @generated from field: repeated world.Camera cameras = 1;
+   * @generated from field: repeated world.MediaStream streams = 1;
+   */
+  streams: MediaStream[];
+
+  /**
+   * If the camera is PTZ, this Entity represents where this camera is looking at
+   * The device driver reconcile target_pose->pose with physical actuation of the gymbal
+   *
+   * @generated from field: optional string focal_point = 2;
+   */
+  focalPoint?: string;
+
+  /**
+   * horizontal field of view in degrees, centered on the entity's azimuth.
+   * For varifocal cameras, this is the current effective FOV (computed by
+   * the engine from fov_wide/fov_tele + zoom if set).
+   *
+   * @generated from field: optional double fov = 3;
+   */
+  fov?: number;
+
+  /**
+   * minimum detection range in meters (blind zone)
+   *
+   * @generated from field: optional double range_min = 4;
+   */
+  rangeMin?: number;
+
+  /**
+   * maximum detection range in meters
+   *
+   * @generated from field: optional double range_max = 5;
    */
-  cameras: Camera[];
+  rangeMax?: number;
+
+  /**
+   * Static optical specs for varifocal/zoom cameras.
+   * When set, the engine computes effective fov from PolarOffset.range (focal distance):
+   *   zoom = range / range_max, fov = fov_wide + zoom * (fov_tele - fov_wide)
+   *
+   * horizontal FOV at widest zoom (degrees)
+   *
+   * @generated from field: optional double fov_wide = 6;
+   */
+  fovWide?: number;
+
+  /**
+   * horizontal FOV at max zoom (degrees)
+   *
+   * @generated from field: optional double fov_tele = 7;
+   */
+  fovTele?: number;
 };
 
 /**
@@ -438,15 +509,24 @@ export declare type DetectionComponent = Message<"world.DetectionComponent"> & {
 export declare const DetectionComponentSchema: GenMessage<DetectionComponent>;
 
 /**
+ * Absolute bearing in the world, relative to the local ENU frame.
+ * For root entities this is set directly; for child entities with a
+ * PolarOffset the engine computes it by composing down the pose tree.
+ *
  * @generated from message world.BearingComponent
  */
 export declare type BearingComponent = Message<"world.BearingComponent"> & {
   /**
+   * clockwise angle from true north in degrees [0, 360)
+   *
    * @generated from field: optional double azimuth = 1;
    */
   azimuth?: number;
 
   /**
+   * angle above the local horizontal plane in degrees [-90, 90]
+   * positive = above horizon, negative = below
+   *
    * @generated from field: optional double elevation = 2;
    */
   elevation?: number;
@@ -549,35 +629,204 @@ export declare type CovarianceMatrix = Message<"world.CovarianceMatrix"> & {
 export declare const CovarianceMatrixSchema: GenMessage<CovarianceMatrix>;
 
 /**
- * @generated from message world.OrientationComponent
+ * @generated from message world.CartesianOffset
  */
-export declare type OrientationComponent = Message<"world.OrientationComponent"> & {
+export declare type CartesianOffset = Message<"world.CartesianOffset"> & {
+  /**
+   * @generated from field: double east_m = 1;
+   */
+  eastM: number;
+
+  /**
+   * @generated from field: double north_m = 2;
+   */
+  northM: number;
+
+  /**
+   * @generated from field: optional double up_m = 3;
+   */
+  upM?: number;
+
   /**
-   * @generated from field: optional world.Quaternion orientation = 1;
+   * @generated from field: optional world.CovarianceMatrix covariance = 4;
+   */
+  covariance?: CovarianceMatrix;
+
+  /**
+   * @generated from field: optional world.Quaternion orientation = 5;
    */
   orientation?: Quaternion;
+};
+
+/**
+ * Describes the message world.CartesianOffset.
+ * Use `create(CartesianOffsetSchema)` to create a new message.
+ */
+export declare const CartesianOffsetSchema: GenMessage<CartesianOffset>;
 
+/**
+ * @generated from message world.PolarOffset
+ */
+export declare type PolarOffset = Message<"world.PolarOffset"> & {
   /**
-   * @generated from field: optional world.CovarianceMatrix covariance = 2;
+   * angle from the parent's forward axis, degrees [0, 360)
+   *
+   * @generated from field: double azimuth = 1;
+   */
+  azimuth: number;
+
+  /**
+   * above the parent's horizontal plane, degrees [-90, 90]
+   *
+   * @generated from field: optional double elevation = 2;
+   */
+  elevation?: number;
+
+  /**
+   * distance in meters. omit for bearing-only (passive sensor)
+   *
+   * @generated from field: optional double range = 3;
+   */
+  range?: number;
+
+  /**
+   * @generated from field: optional world.CovarianceMatrix covariance = 4;
    */
   covariance?: CovarianceMatrix;
 
   /**
-   * angular velocity in radians per second (body frame)
+   * @generated from field: optional world.Quaternion orientation = 5;
+   */
+  orientation?: Quaternion;
+};
+
+/**
+ * Describes the message world.PolarOffset.
+ * Use `create(PolarOffsetSchema)` to create a new message.
+ */
+export declare const PolarOffsetSchema: GenMessage<PolarOffset>;
+
+/**
+ * This entity's pose is defined relative to a parent entity's coordinate frame.
+ * The engine computes absolute GeoSpatialComponent by walking the tree.
+ * If the pose cannot be fully resolved (e.g. missing range), no geo is produced.
+ *
+ * @generated from message world.PoseComponent
+ */
+export declare type PoseComponent = Message<"world.PoseComponent"> & {
+  /**
+   * parent entity in the transform tree
+   *
+   * @generated from field: string parent = 1;
+   */
+  parent: string;
+
+  /**
+   * @generated from oneof world.PoseComponent.offset
+   */
+  offset: {
+    /**
+     * @generated from field: world.CartesianOffset cartesian = 2;
+     */
+    value: CartesianOffset;
+    case: "cartesian";
+  } | {
+    /**
+     * @generated from field: world.PolarOffset polar = 3;
+     */
+    value: PolarOffset;
+    case: "polar";
+  } | { case: undefined; value?: undefined };
+};
+
+/**
+ * Describes the message world.PoseComponent.
+ * Use `create(PoseComponentSchema)` to create a new message.
+ */
+export declare const PoseComponentSchema: GenMessage<PoseComponent>;
+
+/**
+ * Desired pose for this joint, same shape as PoseComponent's offset.
+ * A device specific reconciler continuously drives the actual PoseComponent toward this target.
+ *
+ * @generated from message world.TargetPoseComponent
+ */
+export declare type TargetPoseComponent = Message<"world.TargetPoseComponent"> & {
+  /**
+   * @generated from oneof world.TargetPoseComponent.offset
+   */
+  offset: {
+    /**
+     * @generated from field: world.CartesianOffset cartesian = 1;
+     */
+    value: CartesianOffset;
+    case: "cartesian";
+  } | {
+    /**
+     * @generated from field: world.PolarOffset polar = 2;
+     */
+    value: PolarOffset;
+    case: "polar";
+  } | { case: undefined; value?: undefined };
+};
+
+/**
+ * Describes the message world.TargetPoseComponent.
+ * Use `create(TargetPoseComponentSchema)` to create a new message.
+ */
+export declare const TargetPoseComponentSchema: GenMessage<TargetPoseComponent>;
+
+/**
+ * Angular velocity around the entity's own body axes
+ *
+ * @generated from message world.AngularVelocity
+ */
+export declare type AngularVelocity = Message<"world.AngularVelocity"> & {
+  /**
+   * radians per second
    *
-   * @generated from field: optional double roll_rate = 3;
+   * @generated from field: double roll_rate = 1;
    */
-  rollRate?: number;
+  rollRate: number;
 
   /**
-   * @generated from field: optional double pitch_rate = 4;
+   * radians per second
+   *
+   * @generated from field: double pitch_rate = 2;
    */
-  pitchRate?: number;
+  pitchRate: number;
 
   /**
-   * @generated from field: optional double yaw_rate = 5;
+   * radians per second
+   *
+   * @generated from field: double yaw_rate = 3;
    */
-  yawRate?: number;
+  yawRate: number;
+};
+
+/**
+ * Describes the message world.AngularVelocity.
+ * Use `create(AngularVelocitySchema)` to create a new message.
+ */
+export declare const AngularVelocitySchema: GenMessage<AngularVelocity>;
+
+/**
+ * Absolute orientation in the world, relative to the local ENU frame.
+ * For root entities this is set directly; for child entities the engine
+ * computes it by composing orientations down the pose tree.
+ *
+ * @generated from message world.OrientationComponent
+ */
+export declare type OrientationComponent = Message<"world.OrientationComponent"> & {
+  /**
+   * @generated from field: world.Quaternion orientation = 1;
+   */
+  orientation?: Quaternion;
+
+  /**
+   * @generated from field: optional world.CovarianceMatrix covariance = 2;
+   */
+  covariance?: CovarianceMatrix;
 };
 
 /**
@@ -608,6 +857,13 @@ export declare type TrackComponent = Message<"world.TrackComponent"> & {
    * @generated from field: optional string prediction = 3;
    */
   prediction?: string;
+
+  /**
+   * detection entity IDs that contribute to this track
+   *
+   * @generated from field: repeated string detections = 4;
+   */
+  detections: string[];
 };
 
 /**
@@ -692,6 +948,11 @@ export declare type TaskableComponent = Message<"world.TaskableComponent"> & {
    * @generated from field: google.protobuf.Struct schema = 5;
    */
   schema?: JsonObject;
+
+  /**
+   * @generated from field: world.TaskableMode mode = 6;
+   */
+  mode: TaskableMode;
 };
 
 /**
@@ -700,6 +961,56 @@ export declare type TaskableComponent = Message<"world.TaskableComponent"> & {
  */
 export declare const TaskableComponentSchema: GenMessage<TaskableComponent>;
 
+/**
+ * An instance of a task being executed.
+ * Created by RunTask, referencing a TaskableComponent entity as the definition.
+ * The controller that owns the taskable watches for these and executes them.
+ *
+ * @generated from message world.TaskExecutionComponent
+ */
+export declare type TaskExecutionComponent = Message<"world.TaskExecutionComponent"> & {
+  /**
+   * entity ID of the TaskableComponent that defines this task
+   *
+   * @generated from field: string task = 1;
+   */
+  task: string;
+
+  /**
+   * parameters supplied by the caller, validated against the taskable's schema
+   *
+   * @generated from field: optional google.protobuf.Struct parameters = 2;
+   */
+  parameters?: JsonObject;
+
+  /**
+   * current execution state, updated by the controller
+   *
+   * @generated from field: world.TaskExecutionState state = 3;
+   */
+  state: TaskExecutionState;
+
+  /**
+   * human-readable error or result message
+   *
+   * @generated from field: optional string reason = 4;
+   */
+  reason?: string;
+
+  /**
+   * priority level for PriorityQueue mode (higher = more important)
+   *
+   * @generated from field: optional uint32 priority = 5;
+   */
+  priority?: number;
+};
+
+/**
+ * Describes the message world.TaskExecutionComponent.
+ * Use `create(TaskExecutionComponentSchema)` to create a new message.
+ */
+export declare const TaskExecutionComponentSchema: GenMessage<TaskExecutionComponent>;
+
 /**
  * @generated from message world.KinematicsEnu
  */
@@ -708,8 +1019,8 @@ export declare type KinematicsEnu = Message<"world.KinematicsEnu"> & {
    * Velocity components in the local East-North-Up (ENU) coordinate frame.
    * The ENU frame is a right-handed Cartesian coordinate system with origin
    * at the entity's position (GeoSpatialComponent), where:
-   * - East axis: tangent to the latitude line, pointing eastward
-   * - North axis: tangent to the longitude line, pointing northward
+   * - East axis: tangent to the parallel (line of constant latitude), pointing eastward
+   * - North axis: tangent to the meridian (line of constant longitude), pointing northward
    * - Up axis: perpendicular to the WGS84 ellipsoid, pointing away from Earth center
    *
    * Note: This is NOT a body frame - the axes do not rotate with the entity's
@@ -765,6 +1076,13 @@ export declare type KinematicsComponent = Message<"world.KinematicsComponent"> &
    * @generated from field: optional world.KinematicsEnu accelerationEnu = 2;
    */
   accelerationEnu?: KinematicsEnu;
+
+  /**
+   * Angular velocity around the entity's body axes
+   *
+   * @generated from field: optional world.AngularVelocity angularVelocityBody = 3;
+   */
+  angularVelocityBody?: AngularVelocity;
 };
 
 /**
@@ -2108,6 +2426,13 @@ export declare type RunTaskRequest = Message<"world.RunTaskRequest"> & {
    * @generated from field: string entityId = 1;
    */
   entityId: string;
+
+  /**
+   * priority for PriorityQueue mode (higher = more important)
+   *
+   * @generated from field: optional uint32 priority = 2;
+   */
+  priority?: number;
 };
 
 /**
@@ -2183,44 +2508,158 @@ export enum Priority {
 export declare const PrioritySchema: GenEnum<Priority>;
 
 /**
- * @generated from enum world.CameraProtocol
+ * @generated from enum world.MediaStreamProtocol
  */
-export enum CameraProtocol {
+export enum MediaStreamProtocol {
   /**
-   * @generated from enum value: CameraProtocolUnspecified = 0;
+   * @generated from enum value: MediaStreamProtocolUnspecified = 0;
    */
-  CameraProtocolUnspecified = 0,
+  MediaStreamProtocolUnspecified = 0,
 
   /**
-   * @generated from enum value: CameraProtocolWebrtc = 1;
+   * @generated from enum value: MediaStreamProtocolWebrtc = 1;
+   */
+  MediaStreamProtocolWebrtc = 1,
+
+  /**
+   * @generated from enum value: MediaStreamProtocolHls = 2;
+   */
+  MediaStreamProtocolHls = 2,
+
+  /**
+   * @generated from enum value: MediaStreamProtocolMjpeg = 3;
+   */
+  MediaStreamProtocolMjpeg = 3,
+
+  /**
+   * @generated from enum value: MediaStreamProtocolImage = 4;
+   */
+  MediaStreamProtocolImage = 4,
+
+  /**
+   * @generated from enum value: MediaStreamProtocolIframe = 5;
+   */
+  MediaStreamProtocolIframe = 5,
+
+  /**
+   * @generated from enum value: MediaStreamProtocolRtsp = 6;
+   */
+  MediaStreamProtocolRtsp = 6,
+}
+
+/**
+ * Describes the enum world.MediaStreamProtocol.
+ */
+export declare const MediaStreamProtocolSchema: GenEnum<MediaStreamProtocol>;
+
+/**
+ * @generated from enum world.MediaStreamRole
+ */
+export enum MediaStreamRole {
+  /**
+   * @generated from enum value: MediaStreamRoleUnspecified = 0;
+   */
+  MediaStreamRoleUnspecified = 0,
+
+  /**
+   * primary high-resolution stream
+   *
+   * @generated from enum value: MediaStreamRoleMain = 1;
+   */
+  MediaStreamRoleMain = 1,
+
+  /**
+   * lower-resolution sub stream
+   *
+   * @generated from enum value: MediaStreamRoleSub = 2;
    */
-  CameraProtocolWebrtc = 1,
+  MediaStreamRoleSub = 2,
 
   /**
-   * @generated from enum value: CameraProtocolHls = 2;
+   * still image capture
+   *
+   * @generated from enum value: MediaStreamRoleSnapshot = 3;
+   */
+  MediaStreamRoleSnapshot = 3,
+}
+
+/**
+ * Describes the enum world.MediaStreamRole.
+ */
+export declare const MediaStreamRoleSchema: GenEnum<MediaStreamRole>;
+
+/**
+ * @generated from enum world.TaskableMode
+ */
+export enum TaskableMode {
+  /**
+   * RunTask places the TaskExecutionComponent on the same entity as the
+   * TaskableComponent. Only one execution at a time; a second RunTask while
+   * one is active is rejected.
+   *
+   * @generated from enum value: TaskableModeExclusive = 0;
+   */
+  TaskableModeExclusive = 0,
+
+  /**
+   * Like Exclusive, but a new RunTask replaces the current execution
+   * instead of being rejected.
+   *
+   * @generated from enum value: TaskableModeReconcile = 1;
+   */
+  TaskableModeReconcile = 1,
+
+  /**
+   * RunTask creates a new child entity with the TaskExecutionComponent.
+   * Multiple executions can run in parallel.
+   *
+   * @generated from enum value: TaskableModeSpawn = 2;
+   */
+  TaskableModeSpawn = 2,
+
+  /**
+   * Like Reconcile, but the driver manages a priority queue of active tasks.
+   * RunTask creates child entities; the driver picks the highest-priority one.
+   *
+   * @generated from enum value: TaskableModePriorityQueue = 3;
+   */
+  TaskableModePriorityQueue = 3,
+}
+
+/**
+ * Describes the enum world.TaskableMode.
+ */
+export declare const TaskableModeSchema: GenEnum<TaskableMode>;
+
+/**
+ * @generated from enum world.TaskExecutionState
+ */
+export enum TaskExecutionState {
+  /**
+   * @generated from enum value: TaskExecutionStatePending = 0;
    */
-  CameraProtocolHls = 2,
+  TaskExecutionStatePending = 0,
 
   /**
-   * @generated from enum value: CameraProtocolMjpeg = 3;
+   * @generated from enum value: TaskExecutionStateRunning = 1;
    */
-  CameraProtocolMjpeg = 3,
+  TaskExecutionStateRunning = 1,
 
   /**
-   * @generated from enum value: CameraProtocolImage = 4;
+   * @generated from enum value: TaskExecutionStateCompleted = 2;
    */
-  CameraProtocolImage = 4,
+  TaskExecutionStateCompleted = 2,
 
   /**
-   * @generated from enum value: CameraProtocolIframe = 5;
+   * @generated from enum value: TaskExecutionStateFailed = 3;
    */
-  CameraProtocolIframe = 5,
+  TaskExecutionStateFailed = 3,
 }
 
 /**
- * Describes the enum world.CameraProtocol.
+ * Describes the enum world.TaskExecutionState.
  */
-export declare const CameraProtocolSchema: GenEnum<CameraProtocol>;
+export declare const TaskExecutionStateSchema: GenEnum<TaskExecutionState>;
 
 /**
  * @generated from enum world.ClassificationIdentity