@foxglove/schemas 0.2.0 → 0.5.0

package/src/schemas.ts

@@ -1,6 +1,6 @@
 import { FoxgloveEnumSchema, FoxgloveMessageSchema } from "./types";
 
-const foxglove_Color: FoxgloveMessageSchema = {
+const Color: FoxgloveMessageSchema = {
   type: "message",
   name: "Color",
   description: "A color in RGBA format",
@@ -28,7 +28,7 @@ const foxglove_Color: FoxgloveMessageSchema = {
   ],
 };
 
-const foxglove_Vector2: FoxgloveMessageSchema = {
+const Vector2: FoxgloveMessageSchema = {
   type: "message",
   name: "Vector2",
   description: "A vector in 2D space that represents a direction only",
@@ -46,7 +46,7 @@ const foxglove_Vector2: FoxgloveMessageSchema = {
   ],
 };
 
-const foxglove_Vector3: FoxgloveMessageSchema = {
+const Vector3: FoxgloveMessageSchema = {
   type: "message",
   name: "Vector3",
   description: "A vector in 3D space that represents a direction only",
@@ -70,7 +70,7 @@ const foxglove_Vector3: FoxgloveMessageSchema = {
   ],
 };
 
-const foxglove_Point2: FoxgloveMessageSchema = {
+const Point2: FoxgloveMessageSchema = {
   type: "message",
   name: "Point2",
   description: "A point representing a position in 2D space",
@@ -88,7 +88,7 @@ const foxglove_Point2: FoxgloveMessageSchema = {
   ],
 };
 
-const foxglove_Point3: FoxgloveMessageSchema = {
+const Point3: FoxgloveMessageSchema = {
   type: "message",
   name: "Point3",
   description: "A point representing a position in 3D space",
@@ -112,7 +112,7 @@ const foxglove_Point3: FoxgloveMessageSchema = {
   ],
 };
 
-const foxglove_Quaternion: FoxgloveMessageSchema = {
+const Quaternion: FoxgloveMessageSchema = {
   type: "message",
   name: "Quaternion",
   description: "A [quaternion](https://eater.net/quaternions) representing a rotation in 3D space",
@@ -141,7 +141,7 @@ const foxglove_Quaternion: FoxgloveMessageSchema = {
   ],
 };
 
-const foxglove_Pose: FoxgloveMessageSchema = {
+const Pose: FoxgloveMessageSchema = {
   type: "message",
   name: "Pose",
   description: "A position and orientation for an object or reference frame in 3D space",
@@ -149,18 +149,512 @@ const foxglove_Pose: FoxgloveMessageSchema = {
   fields: [
     {
       name: "position",
-      type: { type: "nested", schema: foxglove_Vector3 },
+      type: { type: "nested", schema: Vector3 },
       description: "Point denoting position in 3D space",
     },
     {
       name: "orientation",
-      type: { type: "nested", schema: foxglove_Quaternion },
+      type: { type: "nested", schema: Quaternion },
       description: "Quaternion denoting orientation in 3D space",
     },
   ],
 };
 
-const foxglove_CameraCalibration: FoxgloveMessageSchema = {
+const KeyValuePair: FoxgloveMessageSchema = {
+  type: "message",
+  name: "KeyValuePair",
+  description: "(Experimental, subject to change) A key with its associated value",
+  fields: [
+    {
+      name: "key",
+      type: { type: "primitive", name: "string" },
+      description: "Key",
+    },
+    {
+      name: "value",
+      type: { type: "primitive", name: "string" },
+      description: "Value",
+    },
+  ],
+};
+
+const SceneEntityDeletionType: FoxgloveEnumSchema = {
+  type: "enum",
+  name: "SceneEntityDeletionType",
+  protobufParentMessageName: "SceneEntityDeletion",
+  protobufEnumName: "Type",
+  description:
+    "(Experimental, subject to change) An enumeration indicating which entities should match a SceneEntityDeletion command",
+  values: [
+    {
+      value: 0,
+      name: "MATCHING_ID",
+      description: "Delete the existing entity on the same topic that has the provided `id`",
+    },
+    { value: 1, name: "ALL", description: "Delete all existing entities on the same topic" },
+  ],
+};
+
+const SceneEntityDeletion: FoxgloveMessageSchema = {
+  type: "message",
+  name: "SceneEntityDeletion",
+  description: "(Experimental, subject to change) Command to remove previously published entities",
+  fields: [
+    {
+      name: "timestamp",
+      type: { type: "primitive", name: "time" },
+      description:
+        "Timestamp of the deletion. Only matching entities earlier than this timestamp will be deleted.",
+    },
+    {
+      name: "type",
+      type: { type: "enum", enum: SceneEntityDeletionType },
+      description: "Type of deletion action to perform",
+    },
+    {
+      name: "id",
+      type: { type: "primitive", name: "string" },
+      description: "Identifier which must match if `type` is `MATCHING_ID`.",
+    },
+  ],
+};
+
+const ArrowPrimitive: FoxgloveMessageSchema = {
+  type: "message",
+  name: "ArrowPrimitive",
+  description: "(Experimental, subject to change) A primitive representing an arrow",
+  fields: [
+    {
+      name: "pose",
+      type: { type: "nested", schema: Pose },
+      description:
+        "Position of the arrow's tail and orientation of the arrow. Identity orientation means the arrow points in the +x direction.",
+    },
+    {
+      name: "shaft_length",
+      type: { type: "primitive", name: "float64" },
+      description: "Length of the arrow shaft",
+    },
+    {
+      name: "shaft_diameter",
+      type: { type: "primitive", name: "float64" },
+      description: "Diameter of the arrow shaft",
+    },
+    {
+      name: "head_length",
+      type: { type: "primitive", name: "float64" },
+      description: "Length of the arrow head",
+    },
+    {
+      name: "head_diameter",
+      type: { type: "primitive", name: "float64" },
+      description: "Diameter of the arrow head",
+    },
+    {
+      name: "color",
+      type: { type: "nested", schema: Color },
+      description: "Color of the arrow",
+    },
+  ],
+};
+
+const CubePrimitive: FoxgloveMessageSchema = {
+  type: "message",
+  name: "CubePrimitive",
+  description:
+    "(Experimental, subject to change) A primitive representing a cube or rectangular prism",
+  fields: [
+    {
+      name: "pose",
+      type: { type: "nested", schema: Pose },
+      description: "Position of the center of the cube and orientation of the cube",
+    },
+    {
+      name: "size",
+      type: { type: "nested", schema: Vector3 },
+      description: "Size of the cube along each axis",
+    },
+    {
+      name: "color",
+      type: { type: "nested", schema: Color },
+      description: "Color of the arrow",
+    },
+  ],
+};
+
+const SpherePrimitive: FoxgloveMessageSchema = {
+  type: "message",
+  name: "SpherePrimitive",
+  description: "(Experimental, subject to change) A primitive representing a sphere or ellipsoid",
+  fields: [
+    {
+      name: "pose",
+      type: { type: "nested", schema: Pose },
+      description: "Position of the center of the sphere and orientation of the sphere",
+    },
+    {
+      name: "size",
+      type: { type: "nested", schema: Vector3 },
+      description: "Size (diameter) of the sphere along each axis",
+    },
+    {
+      name: "color",
+      type: { type: "nested", schema: Color },
+      description: "Color of the sphere",
+    },
+  ],
+};
+
+const CylinderPrimitive: FoxgloveMessageSchema = {
+  type: "message",
+  name: "CylinderPrimitive",
+  description:
+    "(Experimental, subject to change) A primitive representing a cylinder, elliptic cylinder, or truncated cone",
+  fields: [
+    {
+      name: "pose",
+      type: { type: "nested", schema: Pose },
+      description:
+        "Position of the center of the cylinder and orientation of the cylinder. The flat face(s) are perpendicular to the z-axis.",
+    },
+    {
+      name: "size",
+      type: { type: "nested", schema: Vector3 },
+      description: "Size of the cylinder's bounding box",
+    },
+    {
+      name: "bottom_scale",
+      type: { type: "primitive", name: "float64" },
+      description:
+        "0-1, ratio of the diameter of the cylinder's bottom face (min z) to the bottom of the bounding box",
+    },
+    {
+      name: "top_scale",
+      type: { type: "primitive", name: "float64" },
+      description:
+        "0-1, ratio of the diameter of the cylinder's top face (max z) to the top of the bounding box",
+    },
+    {
+      name: "color",
+      type: { type: "nested", schema: Color },
+      description: "Color of the cylinder",
+    },
+  ],
+};
+
+const LineType: FoxgloveEnumSchema = {
+  type: "enum",
+  name: "LineType",
+  protobufParentMessageName: "LinePrimitive",
+  protobufEnumName: "Type",
+  description:
+    "(Experimental, subject to change) An enumeration indicating how input points should be interpreted to create lines",
+  values: [
+    { value: 0, name: "LINE_STRIP", description: "0-1, 1-2, ..., (n-1)-n" },
+    { value: 1, name: "LINE_LOOP", description: "0-1, 1-2, ..., (n-1)-n, n-0" },
+    { value: 2, name: "LINE_LIST", description: "0-1, 2-3, 4-5, ..." },
+  ],
+};
+
+const LinePrimitive: FoxgloveMessageSchema = {
+  type: "message",
+  name: "LinePrimitive",
+  description:
+    "(Experimental, subject to change) A primitive representing a series of points connected by lines",
+  fields: [
+    {
+      name: "type",
+      type: { type: "enum", enum: LineType },
+      description: "Drawing primitive to use for lines",
+    },
+    {
+      name: "pose",
+      type: { type: "nested", schema: Pose },
+      description: "Origin of lines relative to reference frame",
+    },
+    {
+      name: "thickness",
+      type: { type: "primitive", name: "float64" },
+      description: "Line thickness",
+    },
+    {
+      name: "scale_invariant",
+      type: { type: "primitive", name: "boolean" },
+      description:
+        "Indicates whether `thickness` is a fixed size in screen pixels (true), or specified in world coordinates and scales with distance from the camera (false)",
+    },
+    {
+      name: "points",
+      type: { type: "nested", schema: Point3 },
+      array: true,
+      description: "Points along the line",
+    },
+    {
+      name: "color",
+      type: { type: "nested", schema: Color },
+      description:
+        "Solid color to use for the whole line. One of `color` or `colors` must be provided.",
+    },
+    {
+      name: "colors",
+      type: { type: "nested", schema: Color },
+      array: true,
+      description:
+        "Per-point colors (if specified, must have the same length as `points`). One of `color` or `colors` must be provided.",
+    },
+    {
+      name: "indices",
+      type: { type: "primitive", name: "uint32" },
+      array: true,
+      description:
+        "Indices into the `points` and `colors` attribute arrays, which can be used to avoid duplicating attribute data.\n\nIf omitted or empty, indexing will not be used. This default behavior is equivalent to specifying [0, 1, ..., N-1] for the indices (where N is the number of `points` provided).",
+    },
+  ],
+};
+
+const TextPrimitive: FoxgloveMessageSchema = {
+  type: "message",
+  name: "TextPrimitive",
+  description: "(Experimental, subject to change) A primitive representing a text label",
+  fields: [
+    {
+      name: "pose",
+      type: { type: "nested", schema: Pose },
+      description:
+        "Position of the center of the text box and orientation of the text. Identity orientation means the text is oriented in the xy-plane and flows from -x to +x.",
+    },
+    {
+      name: "billboard",
+      type: { type: "primitive", name: "boolean" },
+      description:
+        "Whether the text should respect `pose.orientation` (false) or always face the camera (true)",
+    },
+    {
+      name: "font_size",
+      type: { type: "primitive", name: "float64" },
+      description: "Font size (height of one line of text)",
+    },
+    {
+      name: "scale_invariant",
+      type: { type: "primitive", name: "boolean" },
+      description:
+        "Indicates whether `font_size` is a fixed size in screen pixels (true), or specified in world coordinates and scales with distance from the camera (false)",
+    },
+    {
+      name: "color",
+      type: { type: "nested", schema: Color },
+      description: "Color of the text",
+    },
+    {
+      name: "text",
+      type: { type: "primitive", name: "string" },
+      description: "Text",
+    },
+  ],
+};
+
+const TriangleListPrimitive: FoxgloveMessageSchema = {
+  type: "message",
+  name: "TriangleListPrimitive",
+  description:
+    "(Experimental, subject to change) A primitive representing a set of triangles or a surface tiled by triangles",
+  fields: [
+    {
+      name: "pose",
+      type: { type: "nested", schema: Pose },
+      description: "Origin of triangles relative to reference frame",
+    },
+    {
+      name: "points",
+      type: { type: "nested", schema: Point3 },
+      array: true,
+      description:
+        "Vertices to use for triangles, interpreted as a list of triples (0-1-2, 3-4-5, ...)",
+    },
+    {
+      name: "color",
+      type: { type: "nested", schema: Color },
+      description:
+        "Solid color to use for the whole shape. One of `color` or `colors` must be provided.",
+    },
+    {
+      name: "colors",
+      type: { type: "nested", schema: Color },
+      array: true,
+      description:
+        "Per-vertex colors (if specified, must have the same length as `points`). One of `color` or `colors` must be provided.",
+    },
+    {
+      name: "indices",
+      type: { type: "primitive", name: "uint32" },
+      array: true,
+      description:
+        "Indices into the `points` and `colors` attribute arrays, which can be used to avoid duplicating attribute data.\n\nIf omitted or empty, indexing will not be used. This default behavior is equivalent to specifying [0, 1, ..., N-1] for the indices (where N is the number of `points` provided).",
+    },
+  ],
+};
+
+const ModelPrimitive: FoxgloveMessageSchema = {
+  type: "message",
+  name: "ModelPrimitive",
+  description:
+    "(Experimental, subject to change) A primitive representing a 3D model file loaded from an external URL or embedded data",
+  fields: [
+    {
+      name: "pose",
+      type: { type: "nested", schema: Pose },
+      description: "Origin of model relative to reference frame",
+    },
+    {
+      name: "scale",
+      type: { type: "nested", schema: Vector3 },
+      description: "Scale factor to apply to the model along each axis",
+    },
+    {
+      name: "color",
+      type: { type: "nested", schema: Color },
+      description: "Solid color to use for the whole model if `override_color` is true.",
+    },
+    {
+      name: "override_color",
+      type: { type: "primitive", name: "boolean" },
+      description:
+        "Whether to use the color specified in `color` instead of any materials embedded in the original model.",
+    },
+    {
+      name: "url",
+      type: { type: "primitive", name: "string" },
+      description: "URL pointing to model file. One of `url` or `data` should be provided.",
+    },
+    {
+      name: "media_type",
+      type: { type: "primitive", name: "string" },
+      description:
+        "[Media type](https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types) of embedded model (e.g. `model/gltf-binary`). Required if `data` is provided instead of `url`. Overrides the inferred media type if `url` is provided.",
+    },
+    {
+      name: "data",
+      type: { type: "primitive", name: "bytes" },
+      description:
+        "Embedded model. One of `url` or `data` should be provided. If `data` is provided, `media_type` must be set to indicate the type of the data.",
+    },
+  ],
+};
+
+const SceneEntity: FoxgloveMessageSchema = {
+  type: "message",
+  name: "SceneEntity",
+  description:
+    "(Experimental, subject to change) A visual element in a 3D scene. An entity may be composed of multiple primitives which all share the same frame of reference.",
+  fields: [
+    {
+      name: "timestamp",
+      type: { type: "primitive", name: "time" },
+      description: "Timestamp of the entity",
+    },
+    {
+      name: "frame_id",
+      type: { type: "primitive", name: "string" },
+      description: "Frame of reference",
+    },
+    {
+      name: "id",
+      type: { type: "primitive", name: "string" },
+      description:
+        "Identifier for the entity. A entity will replace any prior entity on the same topic with the same `id`.",
+    },
+    {
+      name: "lifetime",
+      type: { type: "primitive", name: "duration" },
+      description:
+        "Length of time (relative to `timestamp`) after which the entity should be automatically removed. Zero value indicates the entity should remain visible until it is replaced or deleted.",
+    },
+    {
+      name: "frame_locked",
+      type: { type: "primitive", name: "boolean" },
+      description:
+        "Whether the entity should keep its location in the fixed frame (false) or follow the frame specified in `frame_id` as it moves relative to the fixed frame (true)",
+    },
+    {
+      name: "metadata",
+      type: { type: "nested", schema: KeyValuePair },
+      array: true,
+      description:
+        "Additional user-provided metadata associated with the entity. Keys must be unique.",
+    },
+    {
+      name: "arrows",
+      type: { type: "nested", schema: ArrowPrimitive },
+      array: true,
+      description: "Arrow primitives",
+    },
+    {
+      name: "cubes",
+      type: { type: "nested", schema: CubePrimitive },
+      array: true,
+      description: "Cube primitives",
+    },
+    {
+      name: "spheres",
+      type: { type: "nested", schema: SpherePrimitive },
+      array: true,
+      description: "Sphere primitives",
+    },
+    {
+      name: "cylinders",
+      type: { type: "nested", schema: CylinderPrimitive },
+      array: true,
+      description: "Cylinder primitives",
+    },
+    {
+      name: "lines",
+      type: { type: "nested", schema: LinePrimitive },
+      array: true,
+      description: "Line primitives",
+    },
+    {
+      name: "triangles",
+      type: { type: "nested", schema: TriangleListPrimitive },
+      array: true,
+      description: "Triangle list primitives",
+    },
+    {
+      name: "texts",
+      type: { type: "nested", schema: TextPrimitive },
+      array: true,
+      description: "Text primitives",
+    },
+    {
+      name: "models",
+      type: { type: "nested", schema: ModelPrimitive },
+      array: true,
+      description: "Model primitives",
+    },
+  ],
+};
+
+const SceneUpdate: FoxgloveMessageSchema = {
+  type: "message",
+  name: "SceneUpdate",
+  description:
+    "(Experimental, subject to change) An update to the entities displayed in a 3D scene",
+  fields: [
+    {
+      name: "deletions",
+      type: { type: "nested", schema: SceneEntityDeletion },
+      array: true,
+      description: "Scene entities to delete",
+    },
+    {
+      name: "entities",
+      type: { type: "nested", schema: SceneEntity },
+      array: true,
+      description: "Scene entities to add or replace",
+    },
+  ],
+};
+
+const CameraCalibration: FoxgloveMessageSchema = {
   type: "message",
   name: "CameraCalibration",
   description: "Camera calibration parameters",
@@ -250,7 +744,7 @@ This holds for both images of a stereo pair.
   ],
 };
 
-const foxglove_CompressedImage: FoxgloveMessageSchema = {
+const CompressedImage: FoxgloveMessageSchema = {
   type: "message",
   name: "CompressedImage",
   description: "A compressed image",
@@ -273,7 +767,7 @@ const foxglove_CompressedImage: FoxgloveMessageSchema = {
   ],
 };
 
-const foxglove_RawImage: FoxgloveMessageSchema = {
+const RawImage: FoxgloveMessageSchema = {
   type: "message",
   name: "RawImage",
   description: "A raw image",
@@ -311,30 +805,7 @@ const foxglove_RawImage: FoxgloveMessageSchema = {
   ],
 };
 
-const foxglove_Transform: FoxgloveMessageSchema = {
-  type: "message",
-  name: "Transform",
-  description: "A transform in 3D space",
-  fields: [
-    {
-      name: "timestamp",
-      type: { type: "primitive", name: "time" },
-      description: "Transform time",
-    },
-    {
-      name: "translation",
-      type: { type: "nested", schema: foxglove_Vector3 },
-      description: "Translation component of the transform",
-    },
-    {
-      name: "rotation",
-      type: { type: "nested", schema: foxglove_Quaternion },
-      description: "Rotation component of the transform",
-    },
-  ],
-};
-
-const foxglove_FrameTransform: FoxgloveMessageSchema = {
+const FrameTransform: FoxgloveMessageSchema = {
   type: "message",
   name: "FrameTransform",
   description: "A transform between two reference frames in 3D space",
@@ -355,14 +826,19 @@ const foxglove_FrameTransform: FoxgloveMessageSchema = {
       description: "Name of the child frame",
     },
     {
-      name: "transform",
-      type: { type: "nested", schema: foxglove_Transform },
-      description: "Transform from parent frame to child frame",
+      name: "translation",
+      type: { type: "nested", schema: Vector3 },
+      description: "Translation component of the transform",
+    },
+    {
+      name: "rotation",
+      type: { type: "nested", schema: Quaternion },
+      description: "Rotation component of the transform",
     },
   ],
 };
 
-const foxglove_PoseInFrame: FoxgloveMessageSchema = {
+const PoseInFrame: FoxgloveMessageSchema = {
   type: "message",
   name: "PoseInFrame",
   description: "A timestamped pose for an object or reference frame in 3D space",
@@ -379,13 +855,13 @@ const foxglove_PoseInFrame: FoxgloveMessageSchema = {
     },
     {
       name: "pose",
-      type: { type: "nested", schema: foxglove_Pose },
+      type: { type: "nested", schema: Pose },
       description: "Pose in 3D space",
     },
   ],
 };
 
-const foxglove_PosesInFrame: FoxgloveMessageSchema = {
+const PosesInFrame: FoxgloveMessageSchema = {
   type: "message",
   name: "PosesInFrame",
   description: "An array of timestamped poses for an object or reference frame in 3D space",
@@ -402,14 +878,14 @@ const foxglove_PosesInFrame: FoxgloveMessageSchema = {
     },
     {
       name: "poses",
-      type: { type: "nested", schema: foxglove_Pose },
+      type: { type: "nested", schema: Pose },
       description: "Poses in 3D space",
       array: true,
     },
   ],
 };
 
-const foxglove_GeoJSON: FoxgloveMessageSchema = {
+const GeoJSON: FoxgloveMessageSchema = {
   type: "message",
   name: "GeoJSON",
   description: "GeoJSON data for annotating maps",
@@ -422,7 +898,7 @@ const foxglove_GeoJSON: FoxgloveMessageSchema = {
   ],
 };
 
-const foxglove_NumericType: FoxgloveEnumSchema = {
+const NumericType: FoxgloveEnumSchema = {
   type: "enum",
   name: "NumericType",
   description: "Numeric type",
@@ -441,7 +917,7 @@ const foxglove_NumericType: FoxgloveEnumSchema = {
   ],
 };
 
-const foxglove_PackedElementField: FoxgloveMessageSchema = {
+const PackedElementField: FoxgloveMessageSchema = {
   type: "message",
   name: "PackedElementField",
   description: "A field present within each element in a byte array of packed elements.",
@@ -458,13 +934,13 @@ const foxglove_PackedElementField: FoxgloveMessageSchema = {
     },
     {
       name: "type",
-      type: { type: "enum", enum: foxglove_NumericType },
+      type: { type: "enum", enum: NumericType },
       description: "Type of data in the field. Integers are stored using little-endian byte order.",
     },
   ],
 };
 
-const foxglove_Grid: FoxgloveMessageSchema = {
+const Grid: FoxgloveMessageSchema = {
   type: "message",
   name: "Grid",
   description: "A 2D grid of data",
@@ -481,7 +957,7 @@ const foxglove_Grid: FoxgloveMessageSchema = {
     },
     {
       name: "pose",
-      type: { type: "nested", schema: foxglove_Pose },
+      type: { type: "nested", schema: Pose },
       description:
         "Origin of grid's corner relative to frame of reference; grid is positioned in the x-y plane relative to this origin",
     },
@@ -492,7 +968,7 @@ const foxglove_Grid: FoxgloveMessageSchema = {
     },
     {
       name: "cell_size",
-      type: { type: "nested", schema: foxglove_Vector2 },
+      type: { type: "nested", schema: Vector2 },
       description: "Size of single grid cell along x and y axes, relative to `pose`",
     },
     {
@@ -507,7 +983,7 @@ const foxglove_Grid: FoxgloveMessageSchema = {
     },
     {
       name: "fields",
-      type: { type: "nested", schema: foxglove_PackedElementField },
+      type: { type: "nested", schema: PackedElementField },
       array: true,
       description: "Fields in `data`",
     },
@@ -519,7 +995,7 @@ const foxglove_Grid: FoxgloveMessageSchema = {
   ],
 };
 
-const foxglove_CircleAnnotation: FoxgloveMessageSchema = {
+const CircleAnnotation: FoxgloveMessageSchema = {
   type: "message",
   name: "CircleAnnotation",
   description: "A circle annotation on a 2D image",
@@ -531,7 +1007,7 @@ const foxglove_CircleAnnotation: FoxgloveMessageSchema = {
     },
     {
       name: "position",
-      type: { type: "nested", schema: foxglove_Point2 },
+      type: { type: "nested", schema: Point2 },
       description: "Center of the circle in 2D image coordinates",
     },
     {
@@ -546,18 +1022,18 @@ const foxglove_CircleAnnotation: FoxgloveMessageSchema = {
     },
     {
       name: "fill_color",
-      type: { type: "nested", schema: foxglove_Color },
+      type: { type: "nested", schema: Color },
       description: "Fill color",
     },
     {
       name: "outline_color",
-      type: { type: "nested", schema: foxglove_Color },
+      type: { type: "nested", schema: Color },
       description: "Outline color",
     },
   ],
 };
 
-const foxglove_PointsAnnotationType: FoxgloveEnumSchema = {
+const PointsAnnotationType: FoxgloveEnumSchema = {
   type: "enum",
   name: "PointsAnnotationType",
   description: "Type of points annotation",
@@ -572,7 +1048,7 @@ const foxglove_PointsAnnotationType: FoxgloveEnumSchema = {
   ],
 };
 
-const foxglove_PointsAnnotation: FoxgloveMessageSchema = {
+const PointsAnnotation: FoxgloveMessageSchema = {
   type: "message",
   name: "PointsAnnotation",
   description: "An array of points on a 2D image",
@@ -584,50 +1060,61 @@ const foxglove_PointsAnnotation: FoxgloveMessageSchema = {
     },
     {
       name: "type",
-      type: { type: "enum", enum: foxglove_PointsAnnotationType },
+      type: { type: "enum", enum: PointsAnnotationType },
       description: "Type of points annotation to draw",
     },
     {
       name: "points",
-      type: { type: "nested", schema: foxglove_Point2 },
+      type: { type: "nested", schema: Point2 },
       description: "Points in 2D image coordinates",
       array: true,
     },
+    {
+      name: "outline_color",
+      type: { type: "nested", schema: Color },
+      description: "Outline color",
+    },
     {
       name: "outline_colors",
-      type: { type: "nested", schema: foxglove_Color },
-      description: "Outline colors",
+      type: { type: "nested", schema: Color },
+      description:
+        "Per-point colors, if `type` is `POINTS`, or per-segment stroke colors, if `type` is `LINE_LIST`.",
       array: true,
     },
     {
       name: "fill_color",
-      type: { type: "nested", schema: foxglove_Color },
+      type: { type: "nested", schema: Color },
       description: "Fill color",
     },
+    {
+      name: "thickness",
+      type: { type: "primitive", name: "float64" },
+      description: "Stroke thickness",
+    },
   ],
 };
 
-const foxglove_ImageAnnotations: FoxgloveMessageSchema = {
+const ImageAnnotations: FoxgloveMessageSchema = {
   type: "message",
   name: "ImageAnnotations",
   description: "Array of annotations for a 2D image",
   fields: [
     {
       name: "circles",
-      type: { type: "nested", schema: foxglove_CircleAnnotation },
+      type: { type: "nested", schema: CircleAnnotation },
       description: "Circle annotations",
       array: true,
     },
     {
       name: "points",
-      type: { type: "nested", schema: foxglove_PointsAnnotation },
+      type: { type: "nested", schema: PointsAnnotation },
       description: "Points annotations",
       array: true,
     },
   ],
 };
 
-const foxglove_PositionCovarianceType: FoxgloveEnumSchema = {
+const PositionCovarianceType: FoxgloveEnumSchema = {
   type: "enum",
   name: "PositionCovarianceType",
   description: "Type of position covariance",
@@ -641,7 +1128,7 @@ const foxglove_PositionCovarianceType: FoxgloveEnumSchema = {
   ],
 };
 
-const foxglove_LocationFix: FoxgloveMessageSchema = {
+const LocationFix: FoxgloveMessageSchema = {
   type: "message",
   name: "LocationFix",
   description: "A navigation satellite fix for any Global Navigation Satellite System",
@@ -670,14 +1157,14 @@ const foxglove_LocationFix: FoxgloveMessageSchema = {
     },
     {
       name: "position_covariance_type",
-      type: { type: "enum", enum: foxglove_PositionCovarianceType },
+      type: { type: "enum", enum: PositionCovarianceType },
       description:
         "If `position_covariance` is available, `position_covariance_type` must be set to indicate the type of covariance.",
     },
   ],
 };
 
-const foxglove_LogLevel: FoxgloveEnumSchema = {
+const LogLevel: FoxgloveEnumSchema = {
   type: "enum",
   name: "LogLevel",
   description: "Log level",
@@ -693,7 +1180,7 @@ const foxglove_LogLevel: FoxgloveEnumSchema = {
   ],
 };
 
-const foxglove_Log: FoxgloveMessageSchema = {
+const Log: FoxgloveMessageSchema = {
   type: "message",
   name: "Log",
   description: "A log message",
@@ -705,7 +1192,7 @@ const foxglove_Log: FoxgloveMessageSchema = {
     },
     {
       name: "level",
-      type: { type: "enum", enum: foxglove_LogLevel },
+      type: { type: "enum", enum: LogLevel },
       description: "Log level",
     },
     {
@@ -731,7 +1218,7 @@ const foxglove_Log: FoxgloveMessageSchema = {
   ],
 };
 
-const foxglove_PointCloud: FoxgloveMessageSchema = {
+const PointCloud: FoxgloveMessageSchema = {
   type: "message",
   name: "PointCloud",
   description:
@@ -749,7 +1236,7 @@ const foxglove_PointCloud: FoxgloveMessageSchema = {
     },
     {
       name: "pose",
-      type: { type: "nested", schema: foxglove_Pose },
+      type: { type: "nested", schema: Pose },
       description: "The origin of the point cloud relative to the frame of reference",
     },
     {
@@ -759,7 +1246,7 @@ const foxglove_PointCloud: FoxgloveMessageSchema = {
     },
     {
       name: "fields",
-      type: { type: "nested", schema: foxglove_PackedElementField },
+      type: { type: "nested", schema: PackedElementField },
       array: true,
       description: "Fields in the `data`",
     },
@@ -771,7 +1258,7 @@ const foxglove_PointCloud: FoxgloveMessageSchema = {
   ],
 };
 
-const foxglove_LaserScan: FoxgloveMessageSchema = {
+const LaserScan: FoxgloveMessageSchema = {
   type: "message",
   name: "LaserScan",
   description: "A single scan from a planar laser range-finder",
@@ -788,7 +1275,7 @@ const foxglove_LaserScan: FoxgloveMessageSchema = {
     },
     {
       name: "pose",
-      type: { type: "nested", schema: foxglove_Pose },
+      type: { type: "nested", schema: Pose },
       description:
         "Origin of scan relative to frame of reference; points are positioned in the x-y plane relative to this origin; angles are interpreted as counterclockwise rotations around the z axis with 0 rad being in the +x direction",
     },
@@ -819,35 +1306,48 @@ const foxglove_LaserScan: FoxgloveMessageSchema = {
 };
 
 export const foxgloveMessageSchemas = {
-  CameraCalibration: foxglove_CameraCalibration,
-  CircleAnnotation: foxglove_CircleAnnotation,
-  Color: foxglove_Color,
-  CompressedImage: foxglove_CompressedImage,
-  PackedElementField: foxglove_PackedElementField,
-  FrameTransform: foxglove_FrameTransform,
-  GeoJSON: foxglove_GeoJSON,
-  Grid: foxglove_Grid,
-  ImageAnnotations: foxglove_ImageAnnotations,
-  LaserScan: foxglove_LaserScan,
-  LocationFix: foxglove_LocationFix,
-  Log: foxglove_Log,
-  Point2: foxglove_Point2,
-  Point3: foxglove_Point3,
-  PointCloud: foxglove_PointCloud,
-  PointsAnnotation: foxglove_PointsAnnotation,
-  Pose: foxglove_Pose,
-  PoseInFrame: foxglove_PoseInFrame,
-  PosesInFrame: foxglove_PosesInFrame,
-  Quaternion: foxglove_Quaternion,
-  RawImage: foxglove_RawImage,
-  Transform: foxglove_Transform,
-  Vector2: foxglove_Vector2,
-  Vector3: foxglove_Vector3,
+  ArrowPrimitive,
+  CameraCalibration,
+  CircleAnnotation,
+  Color,
+  CompressedImage,
+  CylinderPrimitive,
+  CubePrimitive,
+  FrameTransform,
+  GeoJSON,
+  Grid,
+  ImageAnnotations,
+  KeyValuePair,
+  LaserScan,
+  LinePrimitive,
+  LocationFix,
+  Log,
+  SceneEntityDeletion,
+  SceneEntity,
+  SceneUpdate,
+  ModelPrimitive,
+  PackedElementField,
+  Point2,
+  Point3,
+  PointCloud,
+  PointsAnnotation,
+  Pose,
+  PoseInFrame,
+  PosesInFrame,
+  Quaternion,
+  RawImage,
+  SpherePrimitive,
+  TextPrimitive,
+  TriangleListPrimitive,
+  Vector2,
+  Vector3,
 };
 
 export const foxgloveEnumSchemas = {
-  LogLevel: foxglove_LogLevel,
-  NumericType: foxglove_NumericType,
-  PointsAnnotationType: foxglove_PointsAnnotationType,
-  PositionCovarianceType: foxglove_PositionCovarianceType,
+  LineType,
+  LogLevel,
+  SceneEntityDeletionType,
+  NumericType,
+  PointsAnnotationType,
+  PositionCovarianceType,
 };