@livekit/rtc-node 0.13.2 → 0.13.4

package/src/proto/room_pb.ts

@@ -2752,16 +2752,28 @@ export class RoomEvent extends Message<RoomEvent> {
     case: "chatMessage";
   } | {
     /**
-     * @generated from field: livekit.proto.DataStream.Header stream_header = 30;
+     * @generated from field: livekit.proto.DataStreamHeaderReceived stream_header_received = 30;
      */
-    value: DataStream_Header;
-    case: "streamHeader";
+    value: DataStreamHeaderReceived;
+    case: "streamHeaderReceived";
   } | {
     /**
-     * @generated from field: livekit.proto.DataStream.Chunk stream_chunk = 31;
+     * @generated from field: livekit.proto.DataStreamChunkReceived stream_chunk_received = 31;
      */
-    value: DataStream_Chunk;
-    case: "streamChunk";
+    value: DataStreamChunkReceived;
+    case: "streamChunkReceived";
+  } | {
+    /**
+     * @generated from field: livekit.proto.DataStreamTrailerReceived stream_trailer_received = 32;
+     */
+    value: DataStreamTrailerReceived;
+    case: "streamTrailerReceived";
+  } | {
+    /**
+     * @generated from field: livekit.proto.DataChannelBufferedAmountLowThresholdChanged data_channel_low_threshold_changed = 33;
+     */
+    value: DataChannelBufferedAmountLowThresholdChanged;
+    case: "dataChannelLowThresholdChanged";
   } | { case: undefined; value?: undefined } = { case: undefined };
 
   constructor(data?: PartialMessage<RoomEvent>) {
@@ -2801,8 +2813,10 @@ export class RoomEvent extends Message<RoomEvent> {
     { no: 27, name: "data_packet_received", kind: "message", T: DataPacketReceived, oneof: "message" },
     { no: 28, name: "transcription_received", kind: "message", T: TranscriptionReceived, oneof: "message" },
     { no: 29, name: "chat_message", kind: "message", T: ChatMessageReceived, oneof: "message" },
-    { no: 30, name: "stream_header", kind: "message", T: DataStream_Header, oneof: "message" },
-    { no: 31, name: "stream_chunk", kind: "message", T: DataStream_Chunk, oneof: "message" },
+    { no: 30, name: "stream_header_received", kind: "message", T: DataStreamHeaderReceived, oneof: "message" },
+    { no: 31, name: "stream_chunk_received", kind: "message", T: DataStreamChunkReceived, oneof: "message" },
+    { no: 32, name: "stream_trailer_received", kind: "message", T: DataStreamTrailerReceived, oneof: "message" },
+    { no: 33, name: "data_channel_low_threshold_changed", kind: "message", T: DataChannelBufferedAmountLowThresholdChanged, oneof: "message" },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RoomEvent {
@@ -2841,6 +2855,16 @@ export class RoomInfo extends Message<RoomInfo> {
    */
   metadata?: string;
 
+  /**
+   * @generated from field: required uint64 lossy_dc_buffered_amount_low_threshold = 4;
+   */
+  lossyDcBufferedAmountLowThreshold?: bigint;
+
+  /**
+   * @generated from field: required uint64 reliable_dc_buffered_amount_low_threshold = 5;
+   */
+  reliableDcBufferedAmountLowThreshold?: bigint;
+
   constructor(data?: PartialMessage<RoomInfo>) {
     super();
     proto2.util.initPartial(data, this);
@@ -2852,6 +2876,8 @@ export class RoomInfo extends Message<RoomInfo> {
     { no: 1, name: "sid", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
     { no: 2, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */, req: true },
     { no: 3, name: "metadata", kind: "scalar", T: 9 /* ScalarType.STRING */, req: true },
+    { no: 4, name: "lossy_dc_buffered_amount_low_threshold", kind: "scalar", T: 4 /* ScalarType.UINT64 */, req: true },
+    { no: 5, name: "reliable_dc_buffered_amount_low_threshold", kind: "scalar", T: 4 /* ScalarType.UINT64 */, req: true },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RoomInfo {
@@ -4334,14 +4360,14 @@ export class DataStream_TextHeader extends Message<DataStream_TextHeader> {
   /**
    * Optional: Version for updates/edits
    *
-   * @generated from field: required int32 version = 2;
+   * @generated from field: optional int32 version = 2;
    */
   version?: number;
 
   /**
    * Optional: Reply to specific message
    *
-   * @generated from field: required string reply_to_stream_id = 3;
+   * @generated from field: optional string reply_to_stream_id = 3;
    */
   replyToStreamId?: string;
 
@@ -4355,7 +4381,7 @@ export class DataStream_TextHeader extends Message<DataStream_TextHeader> {
   /**
    * true if the text has been generated by an agent from a participant's audio transcription
    *
-   * @generated from field: required bool generated = 5;
+   * @generated from field: optional bool generated = 5;
    */
   generated?: boolean;
 
@@ -4368,10 +4394,10 @@ export class DataStream_TextHeader extends Message<DataStream_TextHeader> {
   static readonly typeName = "livekit.proto.DataStream.TextHeader";
   static readonly fields: FieldList = proto2.util.newFieldList(() => [
     { no: 1, name: "operation_type", kind: "enum", T: proto2.getEnumType(DataStream_OperationType), req: true },
-    { no: 2, name: "version", kind: "scalar", T: 5 /* ScalarType.INT32 */, req: true },
-    { no: 3, name: "reply_to_stream_id", kind: "scalar", T: 9 /* ScalarType.STRING */, req: true },
+    { no: 2, name: "version", kind: "scalar", T: 5 /* ScalarType.INT32 */, opt: true },
+    { no: 3, name: "reply_to_stream_id", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
     { no: 4, name: "attached_stream_ids", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
-    { no: 5, name: "generated", kind: "scalar", T: 8 /* ScalarType.BOOL */, req: true },
+    { no: 5, name: "generated", kind: "scalar", T: 8 /* ScalarType.BOOL */, opt: true },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): DataStream_TextHeader {
@@ -4392,43 +4418,41 @@ export class DataStream_TextHeader extends Message<DataStream_TextHeader> {
 }
 
 /**
- * header properties specific to file or image streams
+ * header properties specific to byte or file streams
  *
- * @generated from message livekit.proto.DataStream.FileHeader
+ * @generated from message livekit.proto.DataStream.ByteHeader
  */
-export class DataStream_FileHeader extends Message<DataStream_FileHeader> {
+export class DataStream_ByteHeader extends Message<DataStream_ByteHeader> {
   /**
-   * name of the file
-   *
-   * @generated from field: required string file_name = 1;
+   * @generated from field: required string name = 1;
    */
-  fileName?: string;
+  name?: string;
 
-  constructor(data?: PartialMessage<DataStream_FileHeader>) {
+  constructor(data?: PartialMessage<DataStream_ByteHeader>) {
     super();
     proto2.util.initPartial(data, this);
   }
 
   static readonly runtime: typeof proto2 = proto2;
-  static readonly typeName = "livekit.proto.DataStream.FileHeader";
+  static readonly typeName = "livekit.proto.DataStream.ByteHeader";
   static readonly fields: FieldList = proto2.util.newFieldList(() => [
-    { no: 1, name: "file_name", kind: "scalar", T: 9 /* ScalarType.STRING */, req: true },
+    { no: 1, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */, req: true },
   ]);
 
-  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): DataStream_FileHeader {
-    return new DataStream_FileHeader().fromBinary(bytes, options);
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): DataStream_ByteHeader {
+    return new DataStream_ByteHeader().fromBinary(bytes, options);
   }
 
-  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): DataStream_FileHeader {
-    return new DataStream_FileHeader().fromJson(jsonValue, options);
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): DataStream_ByteHeader {
+    return new DataStream_ByteHeader().fromJson(jsonValue, options);
   }
 
-  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): DataStream_FileHeader {
-    return new DataStream_FileHeader().fromJsonString(jsonString, options);
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): DataStream_ByteHeader {
+    return new DataStream_ByteHeader().fromJsonString(jsonString, options);
   }
 
-  static equals(a: DataStream_FileHeader | PlainMessage<DataStream_FileHeader> | undefined, b: DataStream_FileHeader | PlainMessage<DataStream_FileHeader> | undefined): boolean {
-    return proto2.util.equals(DataStream_FileHeader, a, b);
+  static equals(a: DataStream_ByteHeader | PlainMessage<DataStream_ByteHeader> | undefined, b: DataStream_ByteHeader | PlainMessage<DataStream_ByteHeader> | undefined): boolean {
+    return proto2.util.equals(DataStream_ByteHeader, a, b);
   }
 }
 
@@ -4453,14 +4477,14 @@ export class DataStream_Header extends Message<DataStream_Header> {
   timestamp?: bigint;
 
   /**
-   * @generated from field: required string topic = 3;
+   * @generated from field: required string mime_type = 3;
    */
-  topic?: string;
+  mimeType?: string;
 
   /**
-   * @generated from field: required string mime_type = 4;
+   * @generated from field: required string topic = 4;
    */
-  mimeType?: string;
+  topic?: string;
 
   /**
    * only populated for finite streams, if it's a stream of unknown size this stays empty
@@ -4470,18 +4494,11 @@ export class DataStream_Header extends Message<DataStream_Header> {
   totalLength?: bigint;
 
   /**
-   * only populated for finite streams, if it's a stream of unknown size this stays empty
-   *
-   * @generated from field: optional uint64 total_chunks = 6;
-   */
-  totalChunks?: bigint;
-
-  /**
-   * user defined extensions map that can carry additional info
+   * user defined attributes map that can carry additional info
    *
-   * @generated from field: map<string, string> extensions = 7;
+   * @generated from field: map<string, string> attributes = 6;
    */
-  extensions: { [key: string]: string } = {};
+  attributes: { [key: string]: string } = {};
 
   /**
    * oneof to choose between specific header types
@@ -4490,16 +4507,16 @@ export class DataStream_Header extends Message<DataStream_Header> {
    */
   contentHeader: {
     /**
-     * @generated from field: livekit.proto.DataStream.TextHeader text_header = 8;
+     * @generated from field: livekit.proto.DataStream.TextHeader text_header = 7;
      */
     value: DataStream_TextHeader;
     case: "textHeader";
   } | {
     /**
-     * @generated from field: livekit.proto.DataStream.FileHeader file_header = 9;
+     * @generated from field: livekit.proto.DataStream.ByteHeader byte_header = 8;
      */
-    value: DataStream_FileHeader;
-    case: "fileHeader";
+    value: DataStream_ByteHeader;
+    case: "byteHeader";
   } | { case: undefined; value?: undefined } = { case: undefined };
 
   constructor(data?: PartialMessage<DataStream_Header>) {
@@ -4512,13 +4529,12 @@ export class DataStream_Header extends Message<DataStream_Header> {
   static readonly fields: FieldList = proto2.util.newFieldList(() => [
     { no: 1, name: "stream_id", kind: "scalar", T: 9 /* ScalarType.STRING */, req: true },
     { no: 2, name: "timestamp", kind: "scalar", T: 3 /* ScalarType.INT64 */, req: true },
-    { no: 3, name: "topic", kind: "scalar", T: 9 /* ScalarType.STRING */, req: true },
-    { no: 4, name: "mime_type", kind: "scalar", T: 9 /* ScalarType.STRING */, req: true },
+    { no: 3, name: "mime_type", kind: "scalar", T: 9 /* ScalarType.STRING */, req: true },
+    { no: 4, name: "topic", kind: "scalar", T: 9 /* ScalarType.STRING */, req: true },
     { no: 5, name: "total_length", kind: "scalar", T: 4 /* ScalarType.UINT64 */, opt: true },
-    { no: 6, name: "total_chunks", kind: "scalar", T: 4 /* ScalarType.UINT64 */, opt: true },
-    { no: 7, name: "extensions", kind: "map", K: 9 /* ScalarType.STRING */, V: {kind: "scalar", T: 9 /* ScalarType.STRING */} },
-    { no: 8, name: "text_header", kind: "message", T: DataStream_TextHeader, oneof: "content_header" },
-    { no: 9, name: "file_header", kind: "message", T: DataStream_FileHeader, oneof: "content_header" },
+    { no: 6, name: "attributes", kind: "map", K: 9 /* ScalarType.STRING */, V: {kind: "scalar", T: 9 /* ScalarType.STRING */} },
+    { no: 7, name: "text_header", kind: "message", T: DataStream_TextHeader, oneof: "content_header" },
+    { no: 8, name: "byte_header", kind: "message", T: DataStream_ByteHeader, oneof: "content_header" },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): DataStream_Header {
@@ -4561,24 +4577,17 @@ export class DataStream_Chunk extends Message<DataStream_Chunk> {
    */
   content?: Uint8Array;
 
-  /**
-   * true only if this is the last chunk of this stream - can also be sent with empty content
-   *
-   * @generated from field: required bool complete = 4;
-   */
-  complete?: boolean;
-
   /**
    * a version indicating that this chunk_index has been retroactively modified and the original one needs to be replaced
    *
-   * @generated from field: required int32 version = 5;
+   * @generated from field: optional int32 version = 4;
    */
   version?: number;
 
   /**
    * optional, initialization vector for AES-GCM encryption
    *
-   * @generated from field: optional bytes iv = 6;
+   * @generated from field: optional bytes iv = 5;
    */
   iv?: Uint8Array;
 
@@ -4593,9 +4602,8 @@ export class DataStream_Chunk extends Message<DataStream_Chunk> {
     { no: 1, name: "stream_id", kind: "scalar", T: 9 /* ScalarType.STRING */, req: true },
     { no: 2, name: "chunk_index", kind: "scalar", T: 4 /* ScalarType.UINT64 */, req: true },
     { no: 3, name: "content", kind: "scalar", T: 12 /* ScalarType.BYTES */, req: true },
-    { no: 4, name: "complete", kind: "scalar", T: 8 /* ScalarType.BOOL */, req: true },
-    { no: 5, name: "version", kind: "scalar", T: 5 /* ScalarType.INT32 */, req: true },
-    { no: 6, name: "iv", kind: "scalar", T: 12 /* ScalarType.BYTES */, opt: true },
+    { no: 4, name: "version", kind: "scalar", T: 5 /* ScalarType.INT32 */, opt: true },
+    { no: 5, name: "iv", kind: "scalar", T: 12 /* ScalarType.BYTES */, opt: true },
   ]);
 
   static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): DataStream_Chunk {
@@ -4615,3 +4623,715 @@ export class DataStream_Chunk extends Message<DataStream_Chunk> {
   }
 }
 
+/**
+ * @generated from message livekit.proto.DataStream.Trailer
+ */
+export class DataStream_Trailer extends Message<DataStream_Trailer> {
+  /**
+   * unique identifier for this data stream
+   *
+   * @generated from field: required string stream_id = 1;
+   */
+  streamId?: string;
+
+  /**
+   * reason why the stream was closed (could contain "error" / "interrupted" / empty for expected end)
+   *
+   * @generated from field: required string reason = 2;
+   */
+  reason?: string;
+
+  /**
+   * finalizing updates for the stream, can also include additional insights for errors or endTime for transcription
+   *
+   * @generated from field: map<string, string> attributes = 3;
+   */
+  attributes: { [key: string]: string } = {};
+
+  constructor(data?: PartialMessage<DataStream_Trailer>) {
+    super();
+    proto2.util.initPartial(data, this);
+  }
+
+  static readonly runtime: typeof proto2 = proto2;
+  static readonly typeName = "livekit.proto.DataStream.Trailer";
+  static readonly fields: FieldList = proto2.util.newFieldList(() => [
+    { no: 1, name: "stream_id", kind: "scalar", T: 9 /* ScalarType.STRING */, req: true },
+    { no: 2, name: "reason", kind: "scalar", T: 9 /* ScalarType.STRING */, req: true },
+    { no: 3, name: "attributes", kind: "map", K: 9 /* ScalarType.STRING */, V: {kind: "scalar", T: 9 /* ScalarType.STRING */} },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): DataStream_Trailer {
+    return new DataStream_Trailer().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): DataStream_Trailer {
+    return new DataStream_Trailer().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): DataStream_Trailer {
+    return new DataStream_Trailer().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: DataStream_Trailer | PlainMessage<DataStream_Trailer> | undefined, b: DataStream_Trailer | PlainMessage<DataStream_Trailer> | undefined): boolean {
+    return proto2.util.equals(DataStream_Trailer, a, b);
+  }
+}
+
+/**
+ * @generated from message livekit.proto.DataStreamHeaderReceived
+ */
+export class DataStreamHeaderReceived extends Message<DataStreamHeaderReceived> {
+  /**
+   * @generated from field: required string participant_identity = 1;
+   */
+  participantIdentity?: string;
+
+  /**
+   * @generated from field: required livekit.proto.DataStream.Header header = 2;
+   */
+  header?: DataStream_Header;
+
+  constructor(data?: PartialMessage<DataStreamHeaderReceived>) {
+    super();
+    proto2.util.initPartial(data, this);
+  }
+
+  static readonly runtime: typeof proto2 = proto2;
+  static readonly typeName = "livekit.proto.DataStreamHeaderReceived";
+  static readonly fields: FieldList = proto2.util.newFieldList(() => [
+    { no: 1, name: "participant_identity", kind: "scalar", T: 9 /* ScalarType.STRING */, req: true },
+    { no: 2, name: "header", kind: "message", T: DataStream_Header, req: true },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): DataStreamHeaderReceived {
+    return new DataStreamHeaderReceived().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): DataStreamHeaderReceived {
+    return new DataStreamHeaderReceived().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): DataStreamHeaderReceived {
+    return new DataStreamHeaderReceived().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: DataStreamHeaderReceived | PlainMessage<DataStreamHeaderReceived> | undefined, b: DataStreamHeaderReceived | PlainMessage<DataStreamHeaderReceived> | undefined): boolean {
+    return proto2.util.equals(DataStreamHeaderReceived, a, b);
+  }
+}
+
+/**
+ * @generated from message livekit.proto.DataStreamChunkReceived
+ */
+export class DataStreamChunkReceived extends Message<DataStreamChunkReceived> {
+  /**
+   * @generated from field: required string participant_identity = 1;
+   */
+  participantIdentity?: string;
+
+  /**
+   * @generated from field: required livekit.proto.DataStream.Chunk chunk = 2;
+   */
+  chunk?: DataStream_Chunk;
+
+  constructor(data?: PartialMessage<DataStreamChunkReceived>) {
+    super();
+    proto2.util.initPartial(data, this);
+  }
+
+  static readonly runtime: typeof proto2 = proto2;
+  static readonly typeName = "livekit.proto.DataStreamChunkReceived";
+  static readonly fields: FieldList = proto2.util.newFieldList(() => [
+    { no: 1, name: "participant_identity", kind: "scalar", T: 9 /* ScalarType.STRING */, req: true },
+    { no: 2, name: "chunk", kind: "message", T: DataStream_Chunk, req: true },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): DataStreamChunkReceived {
+    return new DataStreamChunkReceived().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): DataStreamChunkReceived {
+    return new DataStreamChunkReceived().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): DataStreamChunkReceived {
+    return new DataStreamChunkReceived().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: DataStreamChunkReceived | PlainMessage<DataStreamChunkReceived> | undefined, b: DataStreamChunkReceived | PlainMessage<DataStreamChunkReceived> | undefined): boolean {
+    return proto2.util.equals(DataStreamChunkReceived, a, b);
+  }
+}
+
+/**
+ * @generated from message livekit.proto.DataStreamTrailerReceived
+ */
+export class DataStreamTrailerReceived extends Message<DataStreamTrailerReceived> {
+  /**
+   * @generated from field: required string participant_identity = 1;
+   */
+  participantIdentity?: string;
+
+  /**
+   * @generated from field: required livekit.proto.DataStream.Trailer trailer = 2;
+   */
+  trailer?: DataStream_Trailer;
+
+  constructor(data?: PartialMessage<DataStreamTrailerReceived>) {
+    super();
+    proto2.util.initPartial(data, this);
+  }
+
+  static readonly runtime: typeof proto2 = proto2;
+  static readonly typeName = "livekit.proto.DataStreamTrailerReceived";
+  static readonly fields: FieldList = proto2.util.newFieldList(() => [
+    { no: 1, name: "participant_identity", kind: "scalar", T: 9 /* ScalarType.STRING */, req: true },
+    { no: 2, name: "trailer", kind: "message", T: DataStream_Trailer, req: true },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): DataStreamTrailerReceived {
+    return new DataStreamTrailerReceived().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): DataStreamTrailerReceived {
+    return new DataStreamTrailerReceived().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): DataStreamTrailerReceived {
+    return new DataStreamTrailerReceived().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: DataStreamTrailerReceived | PlainMessage<DataStreamTrailerReceived> | undefined, b: DataStreamTrailerReceived | PlainMessage<DataStreamTrailerReceived> | undefined): boolean {
+    return proto2.util.equals(DataStreamTrailerReceived, a, b);
+  }
+}
+
+/**
+ * @generated from message livekit.proto.SendStreamHeaderRequest
+ */
+export class SendStreamHeaderRequest extends Message<SendStreamHeaderRequest> {
+  /**
+   * @generated from field: required uint64 local_participant_handle = 1;
+   */
+  localParticipantHandle?: bigint;
+
+  /**
+   * @generated from field: required livekit.proto.DataStream.Header header = 2;
+   */
+  header?: DataStream_Header;
+
+  /**
+   * @generated from field: repeated string destination_identities = 3;
+   */
+  destinationIdentities: string[] = [];
+
+  /**
+   * @generated from field: required string sender_identity = 4;
+   */
+  senderIdentity?: string;
+
+  constructor(data?: PartialMessage<SendStreamHeaderRequest>) {
+    super();
+    proto2.util.initPartial(data, this);
+  }
+
+  static readonly runtime: typeof proto2 = proto2;
+  static readonly typeName = "livekit.proto.SendStreamHeaderRequest";
+  static readonly fields: FieldList = proto2.util.newFieldList(() => [
+    { no: 1, name: "local_participant_handle", kind: "scalar", T: 4 /* ScalarType.UINT64 */, req: true },
+    { no: 2, name: "header", kind: "message", T: DataStream_Header, req: true },
+    { no: 3, name: "destination_identities", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
+    { no: 4, name: "sender_identity", kind: "scalar", T: 9 /* ScalarType.STRING */, req: true },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SendStreamHeaderRequest {
+    return new SendStreamHeaderRequest().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SendStreamHeaderRequest {
+    return new SendStreamHeaderRequest().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SendStreamHeaderRequest {
+    return new SendStreamHeaderRequest().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: SendStreamHeaderRequest | PlainMessage<SendStreamHeaderRequest> | undefined, b: SendStreamHeaderRequest | PlainMessage<SendStreamHeaderRequest> | undefined): boolean {
+    return proto2.util.equals(SendStreamHeaderRequest, a, b);
+  }
+}
+
+/**
+ * @generated from message livekit.proto.SendStreamChunkRequest
+ */
+export class SendStreamChunkRequest extends Message<SendStreamChunkRequest> {
+  /**
+   * @generated from field: required uint64 local_participant_handle = 1;
+   */
+  localParticipantHandle?: bigint;
+
+  /**
+   * @generated from field: required livekit.proto.DataStream.Chunk chunk = 2;
+   */
+  chunk?: DataStream_Chunk;
+
+  /**
+   * @generated from field: repeated string destination_identities = 3;
+   */
+  destinationIdentities: string[] = [];
+
+  /**
+   * @generated from field: required string sender_identity = 4;
+   */
+  senderIdentity?: string;
+
+  constructor(data?: PartialMessage<SendStreamChunkRequest>) {
+    super();
+    proto2.util.initPartial(data, this);
+  }
+
+  static readonly runtime: typeof proto2 = proto2;
+  static readonly typeName = "livekit.proto.SendStreamChunkRequest";
+  static readonly fields: FieldList = proto2.util.newFieldList(() => [
+    { no: 1, name: "local_participant_handle", kind: "scalar", T: 4 /* ScalarType.UINT64 */, req: true },
+    { no: 2, name: "chunk", kind: "message", T: DataStream_Chunk, req: true },
+    { no: 3, name: "destination_identities", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
+    { no: 4, name: "sender_identity", kind: "scalar", T: 9 /* ScalarType.STRING */, req: true },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SendStreamChunkRequest {
+    return new SendStreamChunkRequest().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SendStreamChunkRequest {
+    return new SendStreamChunkRequest().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SendStreamChunkRequest {
+    return new SendStreamChunkRequest().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: SendStreamChunkRequest | PlainMessage<SendStreamChunkRequest> | undefined, b: SendStreamChunkRequest | PlainMessage<SendStreamChunkRequest> | undefined): boolean {
+    return proto2.util.equals(SendStreamChunkRequest, a, b);
+  }
+}
+
+/**
+ * @generated from message livekit.proto.SendStreamTrailerRequest
+ */
+export class SendStreamTrailerRequest extends Message<SendStreamTrailerRequest> {
+  /**
+   * @generated from field: required uint64 local_participant_handle = 1;
+   */
+  localParticipantHandle?: bigint;
+
+  /**
+   * @generated from field: required livekit.proto.DataStream.Trailer trailer = 2;
+   */
+  trailer?: DataStream_Trailer;
+
+  /**
+   * @generated from field: repeated string destination_identities = 3;
+   */
+  destinationIdentities: string[] = [];
+
+  /**
+   * @generated from field: required string sender_identity = 4;
+   */
+  senderIdentity?: string;
+
+  constructor(data?: PartialMessage<SendStreamTrailerRequest>) {
+    super();
+    proto2.util.initPartial(data, this);
+  }
+
+  static readonly runtime: typeof proto2 = proto2;
+  static readonly typeName = "livekit.proto.SendStreamTrailerRequest";
+  static readonly fields: FieldList = proto2.util.newFieldList(() => [
+    { no: 1, name: "local_participant_handle", kind: "scalar", T: 4 /* ScalarType.UINT64 */, req: true },
+    { no: 2, name: "trailer", kind: "message", T: DataStream_Trailer, req: true },
+    { no: 3, name: "destination_identities", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
+    { no: 4, name: "sender_identity", kind: "scalar", T: 9 /* ScalarType.STRING */, req: true },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SendStreamTrailerRequest {
+    return new SendStreamTrailerRequest().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SendStreamTrailerRequest {
+    return new SendStreamTrailerRequest().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SendStreamTrailerRequest {
+    return new SendStreamTrailerRequest().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: SendStreamTrailerRequest | PlainMessage<SendStreamTrailerRequest> | undefined, b: SendStreamTrailerRequest | PlainMessage<SendStreamTrailerRequest> | undefined): boolean {
+    return proto2.util.equals(SendStreamTrailerRequest, a, b);
+  }
+}
+
+/**
+ * @generated from message livekit.proto.SendStreamHeaderResponse
+ */
+export class SendStreamHeaderResponse extends Message<SendStreamHeaderResponse> {
+  /**
+   * @generated from field: required uint64 async_id = 1;
+   */
+  asyncId?: bigint;
+
+  constructor(data?: PartialMessage<SendStreamHeaderResponse>) {
+    super();
+    proto2.util.initPartial(data, this);
+  }
+
+  static readonly runtime: typeof proto2 = proto2;
+  static readonly typeName = "livekit.proto.SendStreamHeaderResponse";
+  static readonly fields: FieldList = proto2.util.newFieldList(() => [
+    { no: 1, name: "async_id", kind: "scalar", T: 4 /* ScalarType.UINT64 */, req: true },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SendStreamHeaderResponse {
+    return new SendStreamHeaderResponse().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SendStreamHeaderResponse {
+    return new SendStreamHeaderResponse().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SendStreamHeaderResponse {
+    return new SendStreamHeaderResponse().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: SendStreamHeaderResponse | PlainMessage<SendStreamHeaderResponse> | undefined, b: SendStreamHeaderResponse | PlainMessage<SendStreamHeaderResponse> | undefined): boolean {
+    return proto2.util.equals(SendStreamHeaderResponse, a, b);
+  }
+}
+
+/**
+ * @generated from message livekit.proto.SendStreamChunkResponse
+ */
+export class SendStreamChunkResponse extends Message<SendStreamChunkResponse> {
+  /**
+   * @generated from field: required uint64 async_id = 1;
+   */
+  asyncId?: bigint;
+
+  constructor(data?: PartialMessage<SendStreamChunkResponse>) {
+    super();
+    proto2.util.initPartial(data, this);
+  }
+
+  static readonly runtime: typeof proto2 = proto2;
+  static readonly typeName = "livekit.proto.SendStreamChunkResponse";
+  static readonly fields: FieldList = proto2.util.newFieldList(() => [
+    { no: 1, name: "async_id", kind: "scalar", T: 4 /* ScalarType.UINT64 */, req: true },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SendStreamChunkResponse {
+    return new SendStreamChunkResponse().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SendStreamChunkResponse {
+    return new SendStreamChunkResponse().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SendStreamChunkResponse {
+    return new SendStreamChunkResponse().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: SendStreamChunkResponse | PlainMessage<SendStreamChunkResponse> | undefined, b: SendStreamChunkResponse | PlainMessage<SendStreamChunkResponse> | undefined): boolean {
+    return proto2.util.equals(SendStreamChunkResponse, a, b);
+  }
+}
+
+/**
+ * @generated from message livekit.proto.SendStreamTrailerResponse
+ */
+export class SendStreamTrailerResponse extends Message<SendStreamTrailerResponse> {
+  /**
+   * @generated from field: required uint64 async_id = 1;
+   */
+  asyncId?: bigint;
+
+  constructor(data?: PartialMessage<SendStreamTrailerResponse>) {
+    super();
+    proto2.util.initPartial(data, this);
+  }
+
+  static readonly runtime: typeof proto2 = proto2;
+  static readonly typeName = "livekit.proto.SendStreamTrailerResponse";
+  static readonly fields: FieldList = proto2.util.newFieldList(() => [
+    { no: 1, name: "async_id", kind: "scalar", T: 4 /* ScalarType.UINT64 */, req: true },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SendStreamTrailerResponse {
+    return new SendStreamTrailerResponse().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SendStreamTrailerResponse {
+    return new SendStreamTrailerResponse().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SendStreamTrailerResponse {
+    return new SendStreamTrailerResponse().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: SendStreamTrailerResponse | PlainMessage<SendStreamTrailerResponse> | undefined, b: SendStreamTrailerResponse | PlainMessage<SendStreamTrailerResponse> | undefined): boolean {
+    return proto2.util.equals(SendStreamTrailerResponse, a, b);
+  }
+}
+
+/**
+ * @generated from message livekit.proto.SendStreamHeaderCallback
+ */
+export class SendStreamHeaderCallback extends Message<SendStreamHeaderCallback> {
+  /**
+   * @generated from field: required uint64 async_id = 1;
+   */
+  asyncId?: bigint;
+
+  /**
+   * @generated from field: optional string error = 2;
+   */
+  error?: string;
+
+  constructor(data?: PartialMessage<SendStreamHeaderCallback>) {
+    super();
+    proto2.util.initPartial(data, this);
+  }
+
+  static readonly runtime: typeof proto2 = proto2;
+  static readonly typeName = "livekit.proto.SendStreamHeaderCallback";
+  static readonly fields: FieldList = proto2.util.newFieldList(() => [
+    { no: 1, name: "async_id", kind: "scalar", T: 4 /* ScalarType.UINT64 */, req: true },
+    { no: 2, name: "error", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SendStreamHeaderCallback {
+    return new SendStreamHeaderCallback().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SendStreamHeaderCallback {
+    return new SendStreamHeaderCallback().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SendStreamHeaderCallback {
+    return new SendStreamHeaderCallback().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: SendStreamHeaderCallback | PlainMessage<SendStreamHeaderCallback> | undefined, b: SendStreamHeaderCallback | PlainMessage<SendStreamHeaderCallback> | undefined): boolean {
+    return proto2.util.equals(SendStreamHeaderCallback, a, b);
+  }
+}
+
+/**
+ * @generated from message livekit.proto.SendStreamChunkCallback
+ */
+export class SendStreamChunkCallback extends Message<SendStreamChunkCallback> {
+  /**
+   * @generated from field: required uint64 async_id = 1;
+   */
+  asyncId?: bigint;
+
+  /**
+   * @generated from field: optional string error = 2;
+   */
+  error?: string;
+
+  constructor(data?: PartialMessage<SendStreamChunkCallback>) {
+    super();
+    proto2.util.initPartial(data, this);
+  }
+
+  static readonly runtime: typeof proto2 = proto2;
+  static readonly typeName = "livekit.proto.SendStreamChunkCallback";
+  static readonly fields: FieldList = proto2.util.newFieldList(() => [
+    { no: 1, name: "async_id", kind: "scalar", T: 4 /* ScalarType.UINT64 */, req: true },
+    { no: 2, name: "error", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SendStreamChunkCallback {
+    return new SendStreamChunkCallback().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SendStreamChunkCallback {
+    return new SendStreamChunkCallback().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SendStreamChunkCallback {
+    return new SendStreamChunkCallback().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: SendStreamChunkCallback | PlainMessage<SendStreamChunkCallback> | undefined, b: SendStreamChunkCallback | PlainMessage<SendStreamChunkCallback> | undefined): boolean {
+    return proto2.util.equals(SendStreamChunkCallback, a, b);
+  }
+}
+
+/**
+ * @generated from message livekit.proto.SendStreamTrailerCallback
+ */
+export class SendStreamTrailerCallback extends Message<SendStreamTrailerCallback> {
+  /**
+   * @generated from field: required uint64 async_id = 1;
+   */
+  asyncId?: bigint;
+
+  /**
+   * @generated from field: optional string error = 2;
+   */
+  error?: string;
+
+  constructor(data?: PartialMessage<SendStreamTrailerCallback>) {
+    super();
+    proto2.util.initPartial(data, this);
+  }
+
+  static readonly runtime: typeof proto2 = proto2;
+  static readonly typeName = "livekit.proto.SendStreamTrailerCallback";
+  static readonly fields: FieldList = proto2.util.newFieldList(() => [
+    { no: 1, name: "async_id", kind: "scalar", T: 4 /* ScalarType.UINT64 */, req: true },
+    { no: 2, name: "error", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SendStreamTrailerCallback {
+    return new SendStreamTrailerCallback().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SendStreamTrailerCallback {
+    return new SendStreamTrailerCallback().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SendStreamTrailerCallback {
+    return new SendStreamTrailerCallback().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: SendStreamTrailerCallback | PlainMessage<SendStreamTrailerCallback> | undefined, b: SendStreamTrailerCallback | PlainMessage<SendStreamTrailerCallback> | undefined): boolean {
+    return proto2.util.equals(SendStreamTrailerCallback, a, b);
+  }
+}
+
+/**
+ * @generated from message livekit.proto.SetDataChannelBufferedAmountLowThresholdRequest
+ */
+export class SetDataChannelBufferedAmountLowThresholdRequest extends Message<SetDataChannelBufferedAmountLowThresholdRequest> {
+  /**
+   * @generated from field: required uint64 local_participant_handle = 1;
+   */
+  localParticipantHandle?: bigint;
+
+  /**
+   * @generated from field: required uint64 threshold = 2;
+   */
+  threshold?: bigint;
+
+  /**
+   * @generated from field: required livekit.proto.DataPacketKind kind = 3;
+   */
+  kind?: DataPacketKind;
+
+  constructor(data?: PartialMessage<SetDataChannelBufferedAmountLowThresholdRequest>) {
+    super();
+    proto2.util.initPartial(data, this);
+  }
+
+  static readonly runtime: typeof proto2 = proto2;
+  static readonly typeName = "livekit.proto.SetDataChannelBufferedAmountLowThresholdRequest";
+  static readonly fields: FieldList = proto2.util.newFieldList(() => [
+    { no: 1, name: "local_participant_handle", kind: "scalar", T: 4 /* ScalarType.UINT64 */, req: true },
+    { no: 2, name: "threshold", kind: "scalar", T: 4 /* ScalarType.UINT64 */, req: true },
+    { no: 3, name: "kind", kind: "enum", T: proto2.getEnumType(DataPacketKind), req: true },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SetDataChannelBufferedAmountLowThresholdRequest {
+    return new SetDataChannelBufferedAmountLowThresholdRequest().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SetDataChannelBufferedAmountLowThresholdRequest {
+    return new SetDataChannelBufferedAmountLowThresholdRequest().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SetDataChannelBufferedAmountLowThresholdRequest {
+    return new SetDataChannelBufferedAmountLowThresholdRequest().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: SetDataChannelBufferedAmountLowThresholdRequest | PlainMessage<SetDataChannelBufferedAmountLowThresholdRequest> | undefined, b: SetDataChannelBufferedAmountLowThresholdRequest | PlainMessage<SetDataChannelBufferedAmountLowThresholdRequest> | undefined): boolean {
+    return proto2.util.equals(SetDataChannelBufferedAmountLowThresholdRequest, a, b);
+  }
+}
+
+/**
+ * @generated from message livekit.proto.SetDataChannelBufferedAmountLowThresholdResponse
+ */
+export class SetDataChannelBufferedAmountLowThresholdResponse extends Message<SetDataChannelBufferedAmountLowThresholdResponse> {
+  constructor(data?: PartialMessage<SetDataChannelBufferedAmountLowThresholdResponse>) {
+    super();
+    proto2.util.initPartial(data, this);
+  }
+
+  static readonly runtime: typeof proto2 = proto2;
+  static readonly typeName = "livekit.proto.SetDataChannelBufferedAmountLowThresholdResponse";
+  static readonly fields: FieldList = proto2.util.newFieldList(() => [
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SetDataChannelBufferedAmountLowThresholdResponse {
+    return new SetDataChannelBufferedAmountLowThresholdResponse().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SetDataChannelBufferedAmountLowThresholdResponse {
+    return new SetDataChannelBufferedAmountLowThresholdResponse().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SetDataChannelBufferedAmountLowThresholdResponse {
+    return new SetDataChannelBufferedAmountLowThresholdResponse().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: SetDataChannelBufferedAmountLowThresholdResponse | PlainMessage<SetDataChannelBufferedAmountLowThresholdResponse> | undefined, b: SetDataChannelBufferedAmountLowThresholdResponse | PlainMessage<SetDataChannelBufferedAmountLowThresholdResponse> | undefined): boolean {
+    return proto2.util.equals(SetDataChannelBufferedAmountLowThresholdResponse, a, b);
+  }
+}
+
+/**
+ * @generated from message livekit.proto.DataChannelBufferedAmountLowThresholdChanged
+ */
+export class DataChannelBufferedAmountLowThresholdChanged extends Message<DataChannelBufferedAmountLowThresholdChanged> {
+  /**
+   * @generated from field: required livekit.proto.DataPacketKind kind = 1;
+   */
+  kind?: DataPacketKind;
+
+  /**
+   * @generated from field: required uint64 threshold = 2;
+   */
+  threshold?: bigint;
+
+  constructor(data?: PartialMessage<DataChannelBufferedAmountLowThresholdChanged>) {
+    super();
+    proto2.util.initPartial(data, this);
+  }
+
+  static readonly runtime: typeof proto2 = proto2;
+  static readonly typeName = "livekit.proto.DataChannelBufferedAmountLowThresholdChanged";
+  static readonly fields: FieldList = proto2.util.newFieldList(() => [
+    { no: 1, name: "kind", kind: "enum", T: proto2.getEnumType(DataPacketKind), req: true },
+    { no: 2, name: "threshold", kind: "scalar", T: 4 /* ScalarType.UINT64 */, req: true },
+  ]);
+
+  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): DataChannelBufferedAmountLowThresholdChanged {
+    return new DataChannelBufferedAmountLowThresholdChanged().fromBinary(bytes, options);
+  }
+
+  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): DataChannelBufferedAmountLowThresholdChanged {
+    return new DataChannelBufferedAmountLowThresholdChanged().fromJson(jsonValue, options);
+  }
+
+  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): DataChannelBufferedAmountLowThresholdChanged {
+    return new DataChannelBufferedAmountLowThresholdChanged().fromJsonString(jsonString, options);
+  }
+
+  static equals(a: DataChannelBufferedAmountLowThresholdChanged | PlainMessage<DataChannelBufferedAmountLowThresholdChanged> | undefined, b: DataChannelBufferedAmountLowThresholdChanged | PlainMessage<DataChannelBufferedAmountLowThresholdChanged> | undefined): boolean {
+    return proto2.util.equals(DataChannelBufferedAmountLowThresholdChanged, a, b);
+  }
+}
+