diff --git a/rbproto/python/shot_pb2.py b/rbproto/python/shot_pb2.py
index 942f192..9dd02cf 100644
--- a/rbproto/python/shot_pb2.py
+++ b/rbproto/python/shot_pb2.py
@@ -13,13 +13,15 @@ _sym_db = _symbol_database.Default()
 
 
 
-DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\nshot.proto\x12\x0fserialized_shot\"?\n\x03\x42ox\x12\x0c\n\x04left\x18\x01 \x01(\x02\x12\x0b\n\x03top\x18\x02 \x01(\x02\x12\r\n\x05width\x18\x03 \x01(\x02\x12\x0e\n\x06height\x18\x04 \x01(\x02\"\x1d\n\x05Point\x12\t\n\x01x\x18\x01 \x01(\x02\x12\t\n\x01y\x18\x02 \x01(\x02\"\x7f\n\rBallDetection\x12.\n\x0eplane_position\x18\x01 \x01(\x0b\x32\x16.serialized_shot.Point\x12(\n\nannotation\x18\x02 \x01(\x0b\x32\x14.serialized_shot.Box\x12\x14\n\x0cinterpolated\x18\x03 \x01(\x08\"T\n\x10RLEBallDetection\x12\x31\n\tdetection\x18\x01 \x01(\x0b\x32\x1e.serialized_shot.BallDetection\x12\r\n\x05\x63ount\x18\x02 \x01(\r\"L\n\x13RLEDetectionHistory\x12\x35\n\ndetections\x18\x01 \x03(\x0b\x32!.serialized_shot.RLEBallDetection\"F\n\x10\x44\x65tectionHistory\x12\x32\n\ndetections\x18\x01 \x03(\x0b\x32\x1e.serialized_shot.BallDetection\"\xe6\x01\n\x04Path\x12\x13\n\x0bstart_frame\x18\x01 \x01(\r\x12\x11\n\tend_frame\x18\x02 \x01(\r\x12\x37\n\ndetections\x18\x03 \x01(\x0b\x32!.serialized_shot.DetectionHistoryH\x00\x12>\n\x0erle_detections\x18\x04 \x01(\x0b\x32$.serialized_shot.RLEDetectionHistoryH\x00\x12\x15\n\x0bnot_present\x18\x05 \x01(\x08H\x00\x12\x11\n\tis_static\x18\x06 \x01(\x08\x42\x13\n\x11\x64\x65tection_history\"R\n\x11IdentifierHistory\x12\x17\n\x0f\x62\x61ll_identifier\x18\x01 \x01(\r\x12$\n\x05paths\x18\x02 \x03(\x0b\x32\x15.serialized_shot.Path\"H\n\x04Shot\x12@\n\x14identifier_histories\x18\x03 \x03(\x0b\x32\".serialized_shot.IdentifierHistoryb\x06proto3')
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\nshot.proto\x12\x0fserialized_shot\"?\n\x03\x42ox\x12\x0c\n\x04left\x18\x01 \x01(\x02\x12\x0b\n\x03top\x18\x02 \x01(\x02\x12\r\n\x05width\x18\x03 \x01(\x02\x12\x0e\n\x06height\x18\x04 \x01(\x02\"\x1d\n\x05Point\x12\t\n\x01x\x18\x01 \x01(\x02\x12\t\n\x01y\x18\x02 \x01(\x02\"\x7f\n\rBallDetection\x12.\n\x0eplane_position\x18\x01 \x01(\x0b\x32\x16.serialized_shot.Point\x12(\n\nannotation\x18\x02 \x01(\x0b\x32\x14.serialized_shot.Box\x12\x14\n\x0cinterpolated\x18\x03 \x01(\x08\"T\n\x10RLEBallDetection\x12\x31\n\tdetection\x18\x01 \x01(\x0b\x32\x1e.serialized_shot.BallDetection\x12\r\n\x05\x63ount\x18\x02 \x01(\r\"L\n\x13RLEDetectionHistory\x12\x35\n\ndetections\x18\x01 \x03(\x0b\x32!.serialized_shot.RLEBallDetection\"F\n\x10\x44\x65tectionHistory\x12\x32\n\ndetections\x18\x01 \x03(\x0b\x32\x1e.serialized_shot.BallDetection\"\xfc\x01\n\rCollisionInfo\x12\x0e\n\x06source\x18\x01 \x01(\r\x12M\n\x10\x62\x61ll_identifiers\x18\x02 \x03(\x0b\x32\x33.serialized_shot.CollisionInfo.BallIdentifiersEntry\x12\x17\n\x0fwall_identifier\x18\x03 \x01(\r\x12\x13\n\x0b\x66rame_index\x18\x04 \x01(\r\x12\x0e\n\x06static\x18\x05 \x01(\x08\x1aN\n\x14\x42\x61llIdentifiersEntry\x12\x0b\n\x03key\x18\x01 \x01(\r\x12%\n\x05value\x18\x02 \x01(\x0b\x32\x16.serialized_shot.Point:\x02\x38\x01\"\xcc\x02\n\x04Path\x12\x13\n\x0bstart_frame\x18\x01 \x01(\r\x12\x11\n\tend_frame\x18\x02 \x01(\r\x12\x37\n\ndetections\x18\x03 \x01(\x0b\x32!.serialized_shot.DetectionHistoryH\x00\x12>\n\x0erle_detections\x18\x04 \x01(\x0b\x32$.serialized_shot.RLEDetectionHistoryH\x00\x12\x15\n\x0bnot_present\x18\x05 \x01(\x08H\x00\x12\x11\n\tis_static\x18\x06 \x01(\x08\x12\x32\n\nstart_info\x18\x07 \x01(\x0b\x32\x1e.serialized_shot.CollisionInfo\x12\x30\n\x08\x65nd_info\x18\x08 \x01(\x0b\x32\x1e.serialized_shot.CollisionInfoB\x13\n\x11\x64\x65tection_history\"R\n\x11IdentifierHistory\x12\x17\n\x0f\x62\x61ll_identifier\x18\x01 \x01(\r\x12$\n\x05paths\x18\x02 \x03(\x0b\x32\x15.serialized_shot.Path\"j\n\x12KeyBallIdentifiers\x12\x10\n\x08\x63ue_ball\x18\x01 \x01(\r\x12\x13\n\x0bobject_ball\x18\x02 \x01(\r\x12\x13\n\x0btarget_ball\x18\x03 \x01(\r\x12\x18\n\x10\x63ontact_sequence\x18\x04 \x03(\r\"\x80\x01\n\x04Shot\x12@\n\x14identifier_histories\x18\x03 \x03(\x0b\x32\".serialized_shot.IdentifierHistory\x12\x36\n\tkey_balls\x18\x04 \x01(\x0b\x32#.serialized_shot.KeyBallIdentifiersb\x06proto3')
 
 _globals = globals()
 _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
 _builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'shot_pb2', _globals)
 if _descriptor._USE_C_DESCRIPTORS == False:
   DESCRIPTOR._options = None
+  _globals['_COLLISIONINFO_BALLIDENTIFIERSENTRY']._options = None
+  _globals['_COLLISIONINFO_BALLIDENTIFIERSENTRY']._serialized_options = b'8\001'
   _globals['_BOX']._serialized_start=31
   _globals['_BOX']._serialized_end=94
   _globals['_POINT']._serialized_start=96
@@ -32,10 +34,16 @@ if _descriptor._USE_C_DESCRIPTORS == False:
   _globals['_RLEDETECTIONHISTORY']._serialized_end=418
   _globals['_DETECTIONHISTORY']._serialized_start=420
   _globals['_DETECTIONHISTORY']._serialized_end=490
-  _globals['_PATH']._serialized_start=493
-  _globals['_PATH']._serialized_end=723
-  _globals['_IDENTIFIERHISTORY']._serialized_start=725
-  _globals['_IDENTIFIERHISTORY']._serialized_end=807
-  _globals['_SHOT']._serialized_start=809
-  _globals['_SHOT']._serialized_end=881
+  _globals['_COLLISIONINFO']._serialized_start=493
+  _globals['_COLLISIONINFO']._serialized_end=745
+  _globals['_COLLISIONINFO_BALLIDENTIFIERSENTRY']._serialized_start=667
+  _globals['_COLLISIONINFO_BALLIDENTIFIERSENTRY']._serialized_end=745
+  _globals['_PATH']._serialized_start=748
+  _globals['_PATH']._serialized_end=1080
+  _globals['_IDENTIFIERHISTORY']._serialized_start=1082
+  _globals['_IDENTIFIERHISTORY']._serialized_end=1164
+  _globals['_KEYBALLIDENTIFIERS']._serialized_start=1166
+  _globals['_KEYBALLIDENTIFIERS']._serialized_end=1272
+  _globals['_SHOT']._serialized_start=1275
+  _globals['_SHOT']._serialized_end=1403
 # @@protoc_insertion_point(module_scope)
diff --git a/rbproto/python/shot_pb2.pyi b/rbproto/python/shot_pb2.pyi
index adc11fa..495a5de 100644
--- a/rbproto/python/shot_pb2.pyi
+++ b/rbproto/python/shot_pb2.pyi
@@ -55,21 +55,46 @@ class DetectionHistory(_message.Message):
     detections: _containers.RepeatedCompositeFieldContainer[BallDetection]
     def __init__(self, detections: _Optional[_Iterable[_Union[BallDetection, _Mapping]]] = ...) -> None: ...
 
+class CollisionInfo(_message.Message):
+    __slots__ = ["source", "ball_identifiers", "wall_identifier", "frame_index", "static"]
+    class BallIdentifiersEntry(_message.Message):
+        __slots__ = ["key", "value"]
+        KEY_FIELD_NUMBER: _ClassVar[int]
+        VALUE_FIELD_NUMBER: _ClassVar[int]
+        key: int
+        value: Point
+        def __init__(self, key: _Optional[int] = ..., value: _Optional[_Union[Point, _Mapping]] = ...) -> None: ...
+    SOURCE_FIELD_NUMBER: _ClassVar[int]
+    BALL_IDENTIFIERS_FIELD_NUMBER: _ClassVar[int]
+    WALL_IDENTIFIER_FIELD_NUMBER: _ClassVar[int]
+    FRAME_INDEX_FIELD_NUMBER: _ClassVar[int]
+    STATIC_FIELD_NUMBER: _ClassVar[int]
+    source: int
+    ball_identifiers: _containers.MessageMap[int, Point]
+    wall_identifier: int
+    frame_index: int
+    static: bool
+    def __init__(self, source: _Optional[int] = ..., ball_identifiers: _Optional[_Mapping[int, Point]] = ..., wall_identifier: _Optional[int] = ..., frame_index: _Optional[int] = ..., static: bool = ...) -> None: ...
+
 class Path(_message.Message):
-    __slots__ = ["start_frame", "end_frame", "detections", "rle_detections", "not_present", "is_static"]
+    __slots__ = ["start_frame", "end_frame", "detections", "rle_detections", "not_present", "is_static", "start_info", "end_info"]
     START_FRAME_FIELD_NUMBER: _ClassVar[int]
     END_FRAME_FIELD_NUMBER: _ClassVar[int]
     DETECTIONS_FIELD_NUMBER: _ClassVar[int]
     RLE_DETECTIONS_FIELD_NUMBER: _ClassVar[int]
     NOT_PRESENT_FIELD_NUMBER: _ClassVar[int]
     IS_STATIC_FIELD_NUMBER: _ClassVar[int]
+    START_INFO_FIELD_NUMBER: _ClassVar[int]
+    END_INFO_FIELD_NUMBER: _ClassVar[int]
     start_frame: int
     end_frame: int
     detections: DetectionHistory
     rle_detections: RLEDetectionHistory
     not_present: bool
     is_static: bool
-    def __init__(self, start_frame: _Optional[int] = ..., end_frame: _Optional[int] = ..., detections: _Optional[_Union[DetectionHistory, _Mapping]] = ..., rle_detections: _Optional[_Union[RLEDetectionHistory, _Mapping]] = ..., not_present: bool = ..., is_static: bool = ...) -> None: ...
+    start_info: CollisionInfo
+    end_info: CollisionInfo
+    def __init__(self, start_frame: _Optional[int] = ..., end_frame: _Optional[int] = ..., detections: _Optional[_Union[DetectionHistory, _Mapping]] = ..., rle_detections: _Optional[_Union[RLEDetectionHistory, _Mapping]] = ..., not_present: bool = ..., is_static: bool = ..., start_info: _Optional[_Union[CollisionInfo, _Mapping]] = ..., end_info: _Optional[_Union[CollisionInfo, _Mapping]] = ...) -> None: ...
 
 class IdentifierHistory(_message.Message):
     __slots__ = ["ball_identifier", "paths"]
@@ -79,8 +104,22 @@ class IdentifierHistory(_message.Message):
     paths: _containers.RepeatedCompositeFieldContainer[Path]
     def __init__(self, ball_identifier: _Optional[int] = ..., paths: _Optional[_Iterable[_Union[Path, _Mapping]]] = ...) -> None: ...
 
+class KeyBallIdentifiers(_message.Message):
+    __slots__ = ["cue_ball", "object_ball", "target_ball", "contact_sequence"]
+    CUE_BALL_FIELD_NUMBER: _ClassVar[int]
+    OBJECT_BALL_FIELD_NUMBER: _ClassVar[int]
+    TARGET_BALL_FIELD_NUMBER: _ClassVar[int]
+    CONTACT_SEQUENCE_FIELD_NUMBER: _ClassVar[int]
+    cue_ball: int
+    object_ball: int
+    target_ball: int
+    contact_sequence: _containers.RepeatedScalarFieldContainer[int]
+    def __init__(self, cue_ball: _Optional[int] = ..., object_ball: _Optional[int] = ..., target_ball: _Optional[int] = ..., contact_sequence: _Optional[_Iterable[int]] = ...) -> None: ...
+
 class Shot(_message.Message):
-    __slots__ = ["identifier_histories"]
+    __slots__ = ["identifier_histories", "key_balls"]
     IDENTIFIER_HISTORIES_FIELD_NUMBER: _ClassVar[int]
+    KEY_BALLS_FIELD_NUMBER: _ClassVar[int]
     identifier_histories: _containers.RepeatedCompositeFieldContainer[IdentifierHistory]
-    def __init__(self, identifier_histories: _Optional[_Iterable[_Union[IdentifierHistory, _Mapping]]] = ...) -> None: ...
+    key_balls: KeyBallIdentifiers
+    def __init__(self, identifier_histories: _Optional[_Iterable[_Union[IdentifierHistory, _Mapping]]] = ..., key_balls: _Optional[_Union[KeyBallIdentifiers, _Mapping]] = ...) -> None: ...
diff --git a/rbproto/shot.proto b/rbproto/shot.proto
index 4e1031b..08106aa 100644
--- a/rbproto/shot.proto
+++ b/rbproto/shot.proto
@@ -3,10 +3,10 @@ syntax = "proto3";
 package serialized_shot;
 
 message Box {
-	float left = 1;
-	float top = 2;
-	float width = 3;
-	float height = 4;
+  float left = 1;
+  float top = 2;
+  float width = 3;
+  float height = 4;
 }
 
 message Point {
@@ -15,14 +15,14 @@ message Point {
 }
 
 message BallDetection {
-	Point plane_position = 1;
-	Box annotation = 2;
-	bool interpolated = 3;
+  Point plane_position = 1;
+  Box annotation = 2;
+  bool interpolated = 3;
 }
 
 message RLEBallDetection {
-	BallDetection detection = 1;
-	uint32 count = 2;
+  BallDetection detection = 1;
+  uint32 count = 2;
 }
 
 message RLEDetectionHistory {
@@ -33,22 +33,43 @@ message DetectionHistory {
   repeated BallDetection detections = 1;
 }
 
+message CollisionInfo {
+  uint32 source = 1;
+  map<uint32, Point> ball_identifiers = 2;
+  uint32 wall_identifier = 3;
+  uint32 frame_index = 4;
+  bool static = 5;
+}
+
 message Path {
   uint32 start_frame = 1;
   uint32 end_frame = 2;
   oneof detection_history {
-	DetectionHistory detections = 3;
-	RLEDetectionHistory rle_detections = 4;
-	bool not_present = 5;
+    DetectionHistory detections = 3;
+    RLEDetectionHistory rle_detections = 4;
+    bool not_present = 5;
   }
   bool is_static = 6;
+  CollisionInfo start_info = 7;
+  CollisionInfo end_info = 8;
 }
 
 message IdentifierHistory {
   uint32 ball_identifier = 1;
   repeated Path paths = 2;
 }
+message KeyBallIdentifiers {
+  uint32 cue_ball = 1;
+  uint32 object_ball = 2;
+  uint32 target_ball = 3;
+
+  // For now this will just be cue->object/target->target
+  // Long term this will potentially represent a linked list
+  // of all balls in a shot.
+  repeated uint32 contact_sequence = 4;
+}
 
 message Shot {
   repeated IdentifierHistory identifier_histories = 3;
+  KeyBallIdentifiers key_balls = 4;
 }
diff --git a/rbproto/ts/shot.ts b/rbproto/ts/shot.ts
index d1c73de..e3399a9 100644
--- a/rbproto/ts/shot.ts
+++ b/rbproto/ts/shot.ts
@@ -427,6 +427,150 @@ function _decodeDetectionHistory(bb: ByteBuffer): DetectionHistory {
   return message;
 }
 
+export interface CollisionInfo {
+  source?: number;
+  ball_identifiers?: { [key: number]: Point };
+  wall_identifier?: number;
+  frame_index?: number;
+  static?: boolean;
+}
+
+export function encodeCollisionInfo(message: CollisionInfo): Uint8Array {
+  let bb = popByteBuffer();
+  _encodeCollisionInfo(message, bb);
+  return toUint8Array(bb);
+}
+
+function _encodeCollisionInfo(message: CollisionInfo, bb: ByteBuffer): void {
+  // optional uint32 source = 1;
+  let $source = message.source;
+  if ($source !== undefined) {
+    writeVarint32(bb, 8);
+    writeVarint32(bb, $source);
+  }
+
+  // optional map<uint32, Point> ball_identifiers = 2;
+  let map$ball_identifiers = message.ball_identifiers;
+  if (map$ball_identifiers !== undefined) {
+    for (let key in map$ball_identifiers) {
+      let nested = popByteBuffer();
+      let value = map$ball_identifiers[key];
+      writeVarint32(nested, 8);
+      writeVarint32(nested, +key);
+      writeVarint32(nested, 18);
+      let nestedValue = popByteBuffer();
+      _encodePoint(value, nestedValue);
+      writeVarint32(nested, nestedValue.limit);
+      writeByteBuffer(nested, nestedValue);
+      pushByteBuffer(nestedValue);
+      writeVarint32(bb, 18);
+      writeVarint32(bb, nested.offset);
+      writeByteBuffer(bb, nested);
+      pushByteBuffer(nested);
+    }
+  }
+
+  // optional uint32 wall_identifier = 3;
+  let $wall_identifier = message.wall_identifier;
+  if ($wall_identifier !== undefined) {
+    writeVarint32(bb, 24);
+    writeVarint32(bb, $wall_identifier);
+  }
+
+  // optional uint32 frame_index = 4;
+  let $frame_index = message.frame_index;
+  if ($frame_index !== undefined) {
+    writeVarint32(bb, 32);
+    writeVarint32(bb, $frame_index);
+  }
+
+  // optional bool static = 5;
+  let $static = message.static;
+  if ($static !== undefined) {
+    writeVarint32(bb, 40);
+    writeByte(bb, $static ? 1 : 0);
+  }
+}
+
+export function decodeCollisionInfo(binary: Uint8Array): CollisionInfo {
+  return _decodeCollisionInfo(wrapByteBuffer(binary));
+}
+
+function _decodeCollisionInfo(bb: ByteBuffer): CollisionInfo {
+  let message: CollisionInfo = {} as any;
+
+  end_of_message: while (!isAtEnd(bb)) {
+    let tag = readVarint32(bb);
+
+    switch (tag >>> 3) {
+      case 0:
+        break end_of_message;
+
+      // optional uint32 source = 1;
+      case 1: {
+        message.source = readVarint32(bb) >>> 0;
+        break;
+      }
+
+      // optional map<uint32, Point> ball_identifiers = 2;
+      case 2: {
+        let values =
+          message.ball_identifiers || (message.ball_identifiers = {});
+        let outerLimit = pushTemporaryLength(bb);
+        let key: number | undefined;
+        let value: Point | undefined;
+        end_of_entry: while (!isAtEnd(bb)) {
+          let tag = readVarint32(bb);
+          switch (tag >>> 3) {
+            case 0:
+              break end_of_entry;
+            case 1: {
+              key = readVarint32(bb) >>> 0;
+              break;
+            }
+            case 2: {
+              let valueLimit = pushTemporaryLength(bb);
+              value = _decodePoint(bb);
+              bb.limit = valueLimit;
+              break;
+            }
+            default:
+              skipUnknownField(bb, tag & 7);
+          }
+        }
+        if (key === undefined || value === undefined)
+          throw new Error("Invalid data for map: ball_identifiers");
+        values[key] = value;
+        bb.limit = outerLimit;
+        break;
+      }
+
+      // optional uint32 wall_identifier = 3;
+      case 3: {
+        message.wall_identifier = readVarint32(bb) >>> 0;
+        break;
+      }
+
+      // optional uint32 frame_index = 4;
+      case 4: {
+        message.frame_index = readVarint32(bb) >>> 0;
+        break;
+      }
+
+      // optional bool static = 5;
+      case 5: {
+        message.static = !!readByte(bb);
+        break;
+      }
+
+      default:
+        skipUnknownField(bb, tag & 7);
+    }
+  }
+
+  return message;
+}
+
 export interface Path {
   start_frame?: number;
   end_frame?: number;
@@ -434,6 +578,8 @@ export interface Path {
   rle_detections?: RLEDetectionHistory;
   not_present?: boolean;
   is_static?: boolean;
+  start_info?: CollisionInfo;
+  end_info?: CollisionInfo;
 }
 
 export function encodePath(message: Path): Uint8Array {
@@ -492,6 +638,28 @@ function _encodePath(message: Path, bb: ByteBuffer): void {
     writeVarint32(bb, 48);
     writeByte(bb, $is_static ? 1 : 0);
   }
+
+  // optional CollisionInfo start_info = 7;
+  let $start_info = message.start_info;
+  if ($start_info !== undefined) {
+    writeVarint32(bb, 58);
+    let nested = popByteBuffer();
+    _encodeCollisionInfo($start_info, nested);
+    writeVarint32(bb, nested.limit);
+    writeByteBuffer(bb, nested);
+    pushByteBuffer(nested);
+  }
+
+  // optional CollisionInfo end_info = 8;
+  let $end_info = message.end_info;
+  if ($end_info !== undefined) {
+    writeVarint32(bb, 66);
+    let nested = popByteBuffer();
+    _encodeCollisionInfo($end_info, nested);
+    writeVarint32(bb, nested.limit);
+    writeByteBuffer(bb, nested);
+    pushByteBuffer(nested);
+  }
 }
 
 export function decodePath(binary: Uint8Array): Path {
@@ -548,6 +716,22 @@ function _decodePath(bb: ByteBuffer): Path {
         break;
       }
 
+      // optional CollisionInfo start_info = 7;
+      case 7: {
+        let limit = pushTemporaryLength(bb);
+        message.start_info = _decodeCollisionInfo(bb);
+        bb.limit = limit;
+        break;
+      }
+
+      // optional CollisionInfo end_info = 8;
+      case 8: {
+        let limit = pushTemporaryLength(bb);
+        message.end_info = _decodeCollisionInfo(bb);
+        bb.limit = limit;
+        break;
+      }
+
       default:
         skipUnknownField(bb, tag & 7);
     }
@@ -631,8 +815,121 @@ function _decodeIdentifierHistory(bb: ByteBuffer): IdentifierHistory {
   return message;
 }
 
+export interface KeyBallIdentifiers {
+  cue_ball?: number;
+  object_ball?: number;
+  target_ball?: number;
+  contact_sequence?: number[];
+}
+
+export function encodeKeyBallIdentifiers(
+  message: KeyBallIdentifiers,
+): Uint8Array {
+  let bb = popByteBuffer();
+  _encodeKeyBallIdentifiers(message, bb);
+  return toUint8Array(bb);
+}
+
+function _encodeKeyBallIdentifiers(
+  message: KeyBallIdentifiers,
+  bb: ByteBuffer,
+): void {
+  // optional uint32 cue_ball = 1;
+  let $cue_ball = message.cue_ball;
+  if ($cue_ball !== undefined) {
+    writeVarint32(bb, 8);
+    writeVarint32(bb, $cue_ball);
+  }
+
+  // optional uint32 object_ball = 2;
+  let $object_ball = message.object_ball;
+  if ($object_ball !== undefined) {
+    writeVarint32(bb, 16);
+    writeVarint32(bb, $object_ball);
+  }
+
+  // optional uint32 target_ball = 3;
+  let $target_ball = message.target_ball;
+  if ($target_ball !== undefined) {
+    writeVarint32(bb, 24);
+    writeVarint32(bb, $target_ball);
+  }
+
+  // repeated uint32 contact_sequence = 4;
+  let array$contact_sequence = message.contact_sequence;
+  if (array$contact_sequence !== undefined) {
+    let packed = popByteBuffer();
+    for (let value of array$contact_sequence) {
+      writeVarint32(packed, value);
+    }
+    writeVarint32(bb, 34);
+    writeVarint32(bb, packed.offset);
+    writeByteBuffer(bb, packed);
+    pushByteBuffer(packed);
+  }
+}
+
+export function decodeKeyBallIdentifiers(
+  binary: Uint8Array,
+): KeyBallIdentifiers {
+  return _decodeKeyBallIdentifiers(wrapByteBuffer(binary));
+}
+
+function _decodeKeyBallIdentifiers(bb: ByteBuffer): KeyBallIdentifiers {
+  let message: KeyBallIdentifiers = {} as any;
+
+  end_of_message: while (!isAtEnd(bb)) {
+    let tag = readVarint32(bb);
+
+    switch (tag >>> 3) {
+      case 0:
+        break end_of_message;
+
+      // optional uint32 cue_ball = 1;
+      case 1: {
+        message.cue_ball = readVarint32(bb) >>> 0;
+        break;
+      }
+
+      // optional uint32 object_ball = 2;
+      case 2: {
+        message.object_ball = readVarint32(bb) >>> 0;
+        break;
+      }
+
+      // optional uint32 target_ball = 3;
+      case 3: {
+        message.target_ball = readVarint32(bb) >>> 0;
+        break;
+      }
+
+      // repeated uint32 contact_sequence = 4;
+      case 4: {
+        let values =
+          message.contact_sequence || (message.contact_sequence = []);
+        if ((tag & 7) === 2) {
+          let outerLimit = pushTemporaryLength(bb);
+          while (!isAtEnd(bb)) {
+            values.push(readVarint32(bb) >>> 0);
+          }
+          bb.limit = outerLimit;
+        } else {
+          values.push(readVarint32(bb) >>> 0);
+        }
+        break;
+      }
+
+      default:
+        skipUnknownField(bb, tag & 7);
+    }
+  }
+
+  return message;
+}
+
 export interface Shot {
   identifier_histories?: IdentifierHistory[];
+  key_balls?: KeyBallIdentifiers;
 }
 
 export function encodeShot(message: Shot): Uint8Array {
@@ -654,6 +951,17 @@ function _encodeShot(message: Shot, bb: ByteBuffer): void {
       pushByteBuffer(nested);
     }
   }
+
+  // optional KeyBallIdentifiers key_balls = 4;
+  let $key_balls = message.key_balls;
+  if ($key_balls !== undefined) {
+    writeVarint32(bb, 34);
+    let nested = popByteBuffer();
+    _encodeKeyBallIdentifiers($key_balls, nested);
+    writeVarint32(bb, nested.limit);
+    writeByteBuffer(bb, nested);
+    pushByteBuffer(nested);
+  }
 }
 
 export function decodeShot(binary: Uint8Array): Shot {
@@ -680,6 +988,14 @@ function _decodeShot(bb: ByteBuffer): Shot {
         break;
       }
 
+      // optional KeyBallIdentifiers key_balls = 4;
+      case 4: {
+        let limit = pushTemporaryLength(bb);
+        message.key_balls = _decodeKeyBallIdentifiers(bb);
+        bb.limit = limit;
+        break;
+      }
+
       default:
         skipUnknownField(bb, tag & 7);
     }