diff --git a/protobuf/video/sfu/models/models.pb.go b/protobuf/video/sfu/models/models.pb.go
index cf8d119dd..b42e0d164 100644
--- a/protobuf/video/sfu/models/models.pb.go
+++ b/protobuf/video/sfu/models/models.pb.go
@@ -2897,6 +2897,418 @@ func (x *PerformanceStats) GetTargetBitrate() int32 {
 	return 0
 }
 
+// ===================================================================
+// BASE (shared by all RTP directions)
+// ===================================================================
+type RtpBase struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Ssrc        uint32  `protobuf:"varint,1,opt,name=ssrc,proto3" json:"ssrc,omitempty"`                                   // raw stat["ssrc"]
+	Kind        string  `protobuf:"bytes,2,opt,name=kind,proto3" json:"kind,omitempty"`                                    // stat["kind"] ("audio","video")
+	TimestampMs float64 `protobuf:"fixed64,3,opt,name=timestamp_ms,json=timestampMs,proto3" json:"timestamp_ms,omitempty"` // stat["timestamp"] in milliseconds
+}
+
+func (x *RtpBase) Reset() {
+	*x = RtpBase{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_video_sfu_models_models_proto_msgTypes[26]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *RtpBase) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*RtpBase) ProtoMessage() {}
+
+func (x *RtpBase) ProtoReflect() protoreflect.Message {
+	mi := &file_video_sfu_models_models_proto_msgTypes[26]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use RtpBase.ProtoReflect.Descriptor instead.
+func (*RtpBase) Descriptor() ([]byte, []int) {
+	return file_video_sfu_models_models_proto_rawDescGZIP(), []int{26}
+}
+
+func (x *RtpBase) GetSsrc() uint32 {
+	if x != nil {
+		return x.Ssrc
+	}
+	return 0
+}
+
+func (x *RtpBase) GetKind() string {
+	if x != nil {
+		return x.Kind
+	}
+	return ""
+}
+
+func (x *RtpBase) GetTimestampMs() float64 {
+	if x != nil {
+		return x.TimestampMs
+	}
+	return 0
+}
+
+// ===================================================================
+// INBOUND (SUBSCRIBER RECEIVING MEDIA)
+// ===================================================================
+type InboundRtp struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Base              *RtpBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
+	JitterSeconds     float64  `protobuf:"fixed64,2,opt,name=jitter_seconds,json=jitterSeconds,proto3" json:"jitter_seconds,omitempty"`               // stat["jitter"]
+	PacketsReceived   uint64   `protobuf:"varint,3,opt,name=packets_received,json=packetsReceived,proto3" json:"packets_received,omitempty"`          // stat["packetsReceived"]
+	PacketsLost       uint64   `protobuf:"varint,4,opt,name=packets_lost,json=packetsLost,proto3" json:"packets_lost,omitempty"`                      // stat["packetsLost"]
+	PacketLossPercent float64  `protobuf:"fixed64,5,opt,name=packet_loss_percent,json=packetLossPercent,proto3" json:"packet_loss_percent,omitempty"` // (packets_lost / (packets_received + packets_lost)) * 100;skip if denominator <= 0 or counters decreased
+	// -------- AUDIO METRICS --------
+	ConcealmentEvents  uint32  `protobuf:"varint,10,opt,name=concealment_events,json=concealmentEvents,proto3" json:"concealment_events,omitempty"`     // stat["concealmentEvents"]
+	ConcealmentPercent float64 `protobuf:"fixed64,11,opt,name=concealment_percent,json=concealmentPercent,proto3" json:"concealment_percent,omitempty"` // (concealedSamples / totalSamplesReceived) * 100 when totalSamplesReceived >= 96_000 (≈2 s @ 48 kHz)
+	// -------- VIDEO METRICS --------
+	Fps                   float64 `protobuf:"fixed64,20,opt,name=fps,proto3" json:"fps,omitempty"`                                                                    // use delta(framesDecoded)/delta(time) with prev sample
+	FreezeDurationSeconds float64 `protobuf:"fixed64,21,opt,name=freeze_duration_seconds,json=freezeDurationSeconds,proto3" json:"freeze_duration_seconds,omitempty"` // stat["totalFreezesDuration"]
+	AvgDecodeTimeSeconds  float64 `protobuf:"fixed64,22,opt,name=avg_decode_time_seconds,json=avgDecodeTimeSeconds,proto3" json:"avg_decode_time_seconds,omitempty"`  // stat["totalDecodeTime"] / max(1, stat["framesDecoded"])
+	MinDimensionPx        uint32  `protobuf:"varint,23,opt,name=min_dimension_px,json=minDimensionPx,proto3" json:"min_dimension_px,omitempty"`                       // min(stat["frameWidth"], stat["frameHeight"]) for video-like tracks
+}
+
+func (x *InboundRtp) Reset() {
+	*x = InboundRtp{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_video_sfu_models_models_proto_msgTypes[27]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *InboundRtp) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*InboundRtp) ProtoMessage() {}
+
+func (x *InboundRtp) ProtoReflect() protoreflect.Message {
+	mi := &file_video_sfu_models_models_proto_msgTypes[27]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use InboundRtp.ProtoReflect.Descriptor instead.
+func (*InboundRtp) Descriptor() ([]byte, []int) {
+	return file_video_sfu_models_models_proto_rawDescGZIP(), []int{27}
+}
+
+func (x *InboundRtp) GetBase() *RtpBase {
+	if x != nil {
+		return x.Base
+	}
+	return nil
+}
+
+func (x *InboundRtp) GetJitterSeconds() float64 {
+	if x != nil {
+		return x.JitterSeconds
+	}
+	return 0
+}
+
+func (x *InboundRtp) GetPacketsReceived() uint64 {
+	if x != nil {
+		return x.PacketsReceived
+	}
+	return 0
+}
+
+func (x *InboundRtp) GetPacketsLost() uint64 {
+	if x != nil {
+		return x.PacketsLost
+	}
+	return 0
+}
+
+func (x *InboundRtp) GetPacketLossPercent() float64 {
+	if x != nil {
+		return x.PacketLossPercent
+	}
+	return 0
+}
+
+func (x *InboundRtp) GetConcealmentEvents() uint32 {
+	if x != nil {
+		return x.ConcealmentEvents
+	}
+	return 0
+}
+
+func (x *InboundRtp) GetConcealmentPercent() float64 {
+	if x != nil {
+		return x.ConcealmentPercent
+	}
+	return 0
+}
+
+func (x *InboundRtp) GetFps() float64 {
+	if x != nil {
+		return x.Fps
+	}
+	return 0
+}
+
+func (x *InboundRtp) GetFreezeDurationSeconds() float64 {
+	if x != nil {
+		return x.FreezeDurationSeconds
+	}
+	return 0
+}
+
+func (x *InboundRtp) GetAvgDecodeTimeSeconds() float64 {
+	if x != nil {
+		return x.AvgDecodeTimeSeconds
+	}
+	return 0
+}
+
+func (x *InboundRtp) GetMinDimensionPx() uint32 {
+	if x != nil {
+		return x.MinDimensionPx
+	}
+	return 0
+}
+
+// ===================================================================
+// OUTBOUND (PUBLISHER SENDING MEDIA)
+// ===================================================================
+type OutboundRtp struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Base                 *RtpBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
+	Fps                  float64  `protobuf:"fixed64,10,opt,name=fps,proto3" json:"fps,omitempty"`                                                                   // delta(framesEncoded)/delta(time) if missing
+	AvgEncodeTimeSeconds float64  `protobuf:"fixed64,11,opt,name=avg_encode_time_seconds,json=avgEncodeTimeSeconds,proto3" json:"avg_encode_time_seconds,omitempty"` // stat["totalEncodeTime"] / max(1, stat["framesEncoded"])
+	BitrateBps           float64  `protobuf:"fixed64,12,opt,name=bitrate_bps,json=bitrateBps,proto3" json:"bitrate_bps,omitempty"`                                   // delta(bytesSent)*8 / delta(timeSeconds); requires prev bytes/timestamp; ignore if delta<=0
+	MinDimensionPx       uint32   `protobuf:"varint,13,opt,name=min_dimension_px,json=minDimensionPx,proto3" json:"min_dimension_px,omitempty"`                      // min(stat["frameWidth"], stat["frameHeight"])
+}
+
+func (x *OutboundRtp) Reset() {
+	*x = OutboundRtp{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_video_sfu_models_models_proto_msgTypes[28]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *OutboundRtp) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*OutboundRtp) ProtoMessage() {}
+
+func (x *OutboundRtp) ProtoReflect() protoreflect.Message {
+	mi := &file_video_sfu_models_models_proto_msgTypes[28]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use OutboundRtp.ProtoReflect.Descriptor instead.
+func (*OutboundRtp) Descriptor() ([]byte, []int) {
+	return file_video_sfu_models_models_proto_rawDescGZIP(), []int{28}
+}
+
+func (x *OutboundRtp) GetBase() *RtpBase {
+	if x != nil {
+		return x.Base
+	}
+	return nil
+}
+
+func (x *OutboundRtp) GetFps() float64 {
+	if x != nil {
+		return x.Fps
+	}
+	return 0
+}
+
+func (x *OutboundRtp) GetAvgEncodeTimeSeconds() float64 {
+	if x != nil {
+		return x.AvgEncodeTimeSeconds
+	}
+	return 0
+}
+
+func (x *OutboundRtp) GetBitrateBps() float64 {
+	if x != nil {
+		return x.BitrateBps
+	}
+	return 0
+}
+
+func (x *OutboundRtp) GetMinDimensionPx() uint32 {
+	if x != nil {
+		return x.MinDimensionPx
+	}
+	return 0
+}
+
+// ===================================================================
+// SFU FEEDBACK: REMOTE-INBOUND (Publisher receives feedback)
+// ===================================================================
+type RemoteInboundRtp struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Base           *RtpBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
+	JitterSeconds  float64  `protobuf:"fixed64,2,opt,name=jitter_seconds,json=jitterSeconds,proto3" json:"jitter_seconds,omitempty"`        // stat["jitter"]
+	RoundTripTimeS float64  `protobuf:"fixed64,3,opt,name=round_trip_time_s,json=roundTripTimeS,proto3" json:"round_trip_time_s,omitempty"` // stat["roundTripTime"]
+}
+
+func (x *RemoteInboundRtp) Reset() {
+	*x = RemoteInboundRtp{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_video_sfu_models_models_proto_msgTypes[29]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *RemoteInboundRtp) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*RemoteInboundRtp) ProtoMessage() {}
+
+func (x *RemoteInboundRtp) ProtoReflect() protoreflect.Message {
+	mi := &file_video_sfu_models_models_proto_msgTypes[29]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use RemoteInboundRtp.ProtoReflect.Descriptor instead.
+func (*RemoteInboundRtp) Descriptor() ([]byte, []int) {
+	return file_video_sfu_models_models_proto_rawDescGZIP(), []int{29}
+}
+
+func (x *RemoteInboundRtp) GetBase() *RtpBase {
+	if x != nil {
+		return x.Base
+	}
+	return nil
+}
+
+func (x *RemoteInboundRtp) GetJitterSeconds() float64 {
+	if x != nil {
+		return x.JitterSeconds
+	}
+	return 0
+}
+
+func (x *RemoteInboundRtp) GetRoundTripTimeS() float64 {
+	if x != nil {
+		return x.RoundTripTimeS
+	}
+	return 0
+}
+
+// ===================================================================
+// SFU FEEDBACK: REMOTE-OUTBOUND (Subscriber receives feedback)
+// ===================================================================
+type RemoteOutboundRtp struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Base           *RtpBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
+	JitterSeconds  float64  `protobuf:"fixed64,2,opt,name=jitter_seconds,json=jitterSeconds,proto3" json:"jitter_seconds,omitempty"`        // stat["jitter"] if provided
+	RoundTripTimeS float64  `protobuf:"fixed64,3,opt,name=round_trip_time_s,json=roundTripTimeS,proto3" json:"round_trip_time_s,omitempty"` // stat["roundTripTime"]
+}
+
+func (x *RemoteOutboundRtp) Reset() {
+	*x = RemoteOutboundRtp{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_video_sfu_models_models_proto_msgTypes[30]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *RemoteOutboundRtp) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*RemoteOutboundRtp) ProtoMessage() {}
+
+func (x *RemoteOutboundRtp) ProtoReflect() protoreflect.Message {
+	mi := &file_video_sfu_models_models_proto_msgTypes[30]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use RemoteOutboundRtp.ProtoReflect.Descriptor instead.
+func (*RemoteOutboundRtp) Descriptor() ([]byte, []int) {
+	return file_video_sfu_models_models_proto_rawDescGZIP(), []int{30}
+}
+
+func (x *RemoteOutboundRtp) GetBase() *RtpBase {
+	if x != nil {
+		return x.Base
+	}
+	return nil
+}
+
+func (x *RemoteOutboundRtp) GetJitterSeconds() float64 {
+	if x != nil {
+		return x.JitterSeconds
+	}
+	return 0
+}
+
+func (x *RemoteOutboundRtp) GetRoundTripTimeS() float64 {
+	if x != nil {
+		return x.RoundTripTimeS
+	}
+	return 0
+}
+
 var File_video_sfu_models_models_proto protoreflect.FileDescriptor
 
 var file_video_sfu_models_models_proto_rawDesc = []byte{
@@ -3220,7 +3632,77 @@ var file_video_sfu_models_models_proto_rawDesc = []byte{
 	0x69, 0x64, 0x65, 0x6f, 0x44, 0x69, 0x6d, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x25, 0x0a,
 	0x0e, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x62, 0x69, 0x74, 0x72, 0x61, 0x74, 0x65, 0x18,
 	0x06, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0d, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x42, 0x69, 0x74,
-	0x72, 0x61, 0x74, 0x65, 0x2a, 0x49, 0x0a, 0x08, 0x50, 0x65, 0x65, 0x72, 0x54, 0x79, 0x70, 0x65,
+	0x72, 0x61, 0x74, 0x65, 0x22, 0x54, 0x0a, 0x07, 0x52, 0x74, 0x70, 0x42, 0x61, 0x73, 0x65, 0x12,
+	0x12, 0x0a, 0x04, 0x73, 0x73, 0x72, 0x63, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x04, 0x73,
+	0x73, 0x72, 0x63, 0x12, 0x12, 0x0a, 0x04, 0x6b, 0x69, 0x6e, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x04, 0x6b, 0x69, 0x6e, 0x64, 0x12, 0x21, 0x0a, 0x0c, 0x74, 0x69, 0x6d, 0x65, 0x73,
+	0x74, 0x61, 0x6d, 0x70, 0x5f, 0x6d, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0b, 0x74,
+	0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x4d, 0x73, 0x22, 0xf2, 0x03, 0x0a, 0x0a, 0x49,
+	0x6e, 0x62, 0x6f, 0x75, 0x6e, 0x64, 0x52, 0x74, 0x70, 0x12, 0x34, 0x0a, 0x04, 0x62, 0x61, 0x73,
+	0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d,
+	0x2e, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x2e, 0x73, 0x66, 0x75, 0x2e, 0x6d, 0x6f, 0x64, 0x65, 0x6c,
+	0x73, 0x2e, 0x52, 0x74, 0x70, 0x42, 0x61, 0x73, 0x65, 0x52, 0x04, 0x62, 0x61, 0x73, 0x65, 0x12,
+	0x25, 0x0a, 0x0e, 0x6a, 0x69, 0x74, 0x74, 0x65, 0x72, 0x5f, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64,
+	0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0d, 0x6a, 0x69, 0x74, 0x74, 0x65, 0x72, 0x53,
+	0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x12, 0x29, 0x0a, 0x10, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74,
+	0x73, 0x5f, 0x72, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04,
+	0x52, 0x0f, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x73, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65,
+	0x64, 0x12, 0x21, 0x0a, 0x0c, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x73, 0x5f, 0x6c, 0x6f, 0x73,
+	0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0b, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x73,
+	0x4c, 0x6f, 0x73, 0x74, 0x12, 0x2e, 0x0a, 0x13, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x5f, 0x6c,
+	0x6f, 0x73, 0x73, 0x5f, 0x70, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28,
+	0x01, 0x52, 0x11, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x4c, 0x6f, 0x73, 0x73, 0x50, 0x65, 0x72,
+	0x63, 0x65, 0x6e, 0x74, 0x12, 0x2d, 0x0a, 0x12, 0x63, 0x6f, 0x6e, 0x63, 0x65, 0x61, 0x6c, 0x6d,
+	0x65, 0x6e, 0x74, 0x5f, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0d,
+	0x52, 0x11, 0x63, 0x6f, 0x6e, 0x63, 0x65, 0x61, 0x6c, 0x6d, 0x65, 0x6e, 0x74, 0x45, 0x76, 0x65,
+	0x6e, 0x74, 0x73, 0x12, 0x2f, 0x0a, 0x13, 0x63, 0x6f, 0x6e, 0x63, 0x65, 0x61, 0x6c, 0x6d, 0x65,
+	0x6e, 0x74, 0x5f, 0x70, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x01,
+	0x52, 0x12, 0x63, 0x6f, 0x6e, 0x63, 0x65, 0x61, 0x6c, 0x6d, 0x65, 0x6e, 0x74, 0x50, 0x65, 0x72,
+	0x63, 0x65, 0x6e, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x66, 0x70, 0x73, 0x18, 0x14, 0x20, 0x01, 0x28,
+	0x01, 0x52, 0x03, 0x66, 0x70, 0x73, 0x12, 0x36, 0x0a, 0x17, 0x66, 0x72, 0x65, 0x65, 0x7a, 0x65,
+	0x5f, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64,
+	0x73, 0x18, 0x15, 0x20, 0x01, 0x28, 0x01, 0x52, 0x15, 0x66, 0x72, 0x65, 0x65, 0x7a, 0x65, 0x44,
+	0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x12, 0x35,
+	0x0a, 0x17, 0x61, 0x76, 0x67, 0x5f, 0x64, 0x65, 0x63, 0x6f, 0x64, 0x65, 0x5f, 0x74, 0x69, 0x6d,
+	0x65, 0x5f, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x18, 0x16, 0x20, 0x01, 0x28, 0x01, 0x52,
+	0x14, 0x61, 0x76, 0x67, 0x44, 0x65, 0x63, 0x6f, 0x64, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x53, 0x65,
+	0x63, 0x6f, 0x6e, 0x64, 0x73, 0x12, 0x28, 0x0a, 0x10, 0x6d, 0x69, 0x6e, 0x5f, 0x64, 0x69, 0x6d,
+	0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x70, 0x78, 0x18, 0x17, 0x20, 0x01, 0x28, 0x0d, 0x52,
+	0x0e, 0x6d, 0x69, 0x6e, 0x44, 0x69, 0x6d, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x50, 0x78, 0x22,
+	0xd7, 0x01, 0x0a, 0x0b, 0x4f, 0x75, 0x74, 0x62, 0x6f, 0x75, 0x6e, 0x64, 0x52, 0x74, 0x70, 0x12,
+	0x34, 0x0a, 0x04, 0x62, 0x61, 0x73, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e,
+	0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x2e, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x2e, 0x73, 0x66, 0x75,
+	0x2e, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x73, 0x2e, 0x52, 0x74, 0x70, 0x42, 0x61, 0x73, 0x65, 0x52,
+	0x04, 0x62, 0x61, 0x73, 0x65, 0x12, 0x10, 0x0a, 0x03, 0x66, 0x70, 0x73, 0x18, 0x0a, 0x20, 0x01,
+	0x28, 0x01, 0x52, 0x03, 0x66, 0x70, 0x73, 0x12, 0x35, 0x0a, 0x17, 0x61, 0x76, 0x67, 0x5f, 0x65,
+	0x6e, 0x63, 0x6f, 0x64, 0x65, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x73, 0x65, 0x63, 0x6f, 0x6e,
+	0x64, 0x73, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x01, 0x52, 0x14, 0x61, 0x76, 0x67, 0x45, 0x6e, 0x63,
+	0x6f, 0x64, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x53, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x12, 0x1f,
+	0x0a, 0x0b, 0x62, 0x69, 0x74, 0x72, 0x61, 0x74, 0x65, 0x5f, 0x62, 0x70, 0x73, 0x18, 0x0c, 0x20,
+	0x01, 0x28, 0x01, 0x52, 0x0a, 0x62, 0x69, 0x74, 0x72, 0x61, 0x74, 0x65, 0x42, 0x70, 0x73, 0x12,
+	0x28, 0x0a, 0x10, 0x6d, 0x69, 0x6e, 0x5f, 0x64, 0x69, 0x6d, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e,
+	0x5f, 0x70, 0x78, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0e, 0x6d, 0x69, 0x6e, 0x44, 0x69,
+	0x6d, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x50, 0x78, 0x22, 0x9a, 0x01, 0x0a, 0x10, 0x52, 0x65,
+	0x6d, 0x6f, 0x74, 0x65, 0x49, 0x6e, 0x62, 0x6f, 0x75, 0x6e, 0x64, 0x52, 0x74, 0x70, 0x12, 0x34,
+	0x0a, 0x04, 0x62, 0x61, 0x73, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x73,
+	0x74, 0x72, 0x65, 0x61, 0x6d, 0x2e, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x2e, 0x73, 0x66, 0x75, 0x2e,
+	0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x73, 0x2e, 0x52, 0x74, 0x70, 0x42, 0x61, 0x73, 0x65, 0x52, 0x04,
+	0x62, 0x61, 0x73, 0x65, 0x12, 0x25, 0x0a, 0x0e, 0x6a, 0x69, 0x74, 0x74, 0x65, 0x72, 0x5f, 0x73,
+	0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0d, 0x6a, 0x69,
+	0x74, 0x74, 0x65, 0x72, 0x53, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x12, 0x29, 0x0a, 0x11, 0x72,
+	0x6f, 0x75, 0x6e, 0x64, 0x5f, 0x74, 0x72, 0x69, 0x70, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x73,
+	0x18, 0x03, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0e, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x54, 0x72, 0x69,
+	0x70, 0x54, 0x69, 0x6d, 0x65, 0x53, 0x22, 0x9b, 0x01, 0x0a, 0x11, 0x52, 0x65, 0x6d, 0x6f, 0x74,
+	0x65, 0x4f, 0x75, 0x74, 0x62, 0x6f, 0x75, 0x6e, 0x64, 0x52, 0x74, 0x70, 0x12, 0x34, 0x0a, 0x04,
+	0x62, 0x61, 0x73, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x73, 0x74, 0x72,
+	0x65, 0x61, 0x6d, 0x2e, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x2e, 0x73, 0x66, 0x75, 0x2e, 0x6d, 0x6f,
+	0x64, 0x65, 0x6c, 0x73, 0x2e, 0x52, 0x74, 0x70, 0x42, 0x61, 0x73, 0x65, 0x52, 0x04, 0x62, 0x61,
+	0x73, 0x65, 0x12, 0x25, 0x0a, 0x0e, 0x6a, 0x69, 0x74, 0x74, 0x65, 0x72, 0x5f, 0x73, 0x65, 0x63,
+	0x6f, 0x6e, 0x64, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0d, 0x6a, 0x69, 0x74, 0x74,
+	0x65, 0x72, 0x53, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x12, 0x29, 0x0a, 0x11, 0x72, 0x6f, 0x75,
+	0x6e, 0x64, 0x5f, 0x74, 0x72, 0x69, 0x70, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x73, 0x18, 0x03,
+	0x20, 0x01, 0x28, 0x01, 0x52, 0x0e, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x54, 0x72, 0x69, 0x70, 0x54,
+	0x69, 0x6d, 0x65, 0x53, 0x2a, 0x49, 0x0a, 0x08, 0x50, 0x65, 0x65, 0x72, 0x54, 0x79, 0x70, 0x65,
 	0x12, 0x23, 0x0a, 0x1f, 0x50, 0x45, 0x45, 0x52, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x50, 0x55,
 	0x42, 0x4c, 0x49, 0x53, 0x48, 0x45, 0x52, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46,
 	0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x18, 0x0a, 0x14, 0x50, 0x45, 0x45, 0x52, 0x5f, 0x54, 0x59,
@@ -3453,7 +3935,7 @@ func file_video_sfu_models_models_proto_rawDescGZIP() []byte {
 }
 
 var file_video_sfu_models_models_proto_enumTypes = make([]protoimpl.EnumInfo, 15)
-var file_video_sfu_models_models_proto_msgTypes = make([]protoimpl.MessageInfo, 26)
+var file_video_sfu_models_models_proto_msgTypes = make([]protoimpl.MessageInfo, 31)
 var file_video_sfu_models_models_proto_goTypes = []interface{}{
 	(PeerType)(0),                   // 0: stream.video.sfu.models.PeerType
 	(ConnectionQuality)(0),          // 1: stream.video.sfu.models.ConnectionQuality
@@ -3496,18 +3978,23 @@ var file_video_sfu_models_models_proto_goTypes = []interface{}{
 	(*AndroidState)(nil),            // 38: stream.video.sfu.models.AndroidState
 	(*AppleState)(nil),              // 39: stream.video.sfu.models.AppleState
 	(*PerformanceStats)(nil),        // 40: stream.video.sfu.models.PerformanceStats
-	(*timestamppb.Timestamp)(nil),   // 41: google.protobuf.Timestamp
-	(*structpb.Struct)(nil),         // 42: google.protobuf.Struct
+	(*RtpBase)(nil),                 // 41: stream.video.sfu.models.RtpBase
+	(*InboundRtp)(nil),              // 42: stream.video.sfu.models.InboundRtp
+	(*OutboundRtp)(nil),             // 43: stream.video.sfu.models.OutboundRtp
+	(*RemoteInboundRtp)(nil),        // 44: stream.video.sfu.models.RemoteInboundRtp
+	(*RemoteOutboundRtp)(nil),       // 45: stream.video.sfu.models.RemoteOutboundRtp
+	(*timestamppb.Timestamp)(nil),   // 46: google.protobuf.Timestamp
+	(*structpb.Struct)(nil),         // 47: google.protobuf.Struct
 }
 var file_video_sfu_models_models_proto_depIdxs = []int32{
 	18, // 0: stream.video.sfu.models.CallState.participants:type_name -> stream.video.sfu.models.Participant
-	41, // 1: stream.video.sfu.models.CallState.started_at:type_name -> google.protobuf.Timestamp
+	46, // 1: stream.video.sfu.models.CallState.started_at:type_name -> google.protobuf.Timestamp
 	16, // 2: stream.video.sfu.models.CallState.participant_count:type_name -> stream.video.sfu.models.ParticipantCount
 	17, // 3: stream.video.sfu.models.CallState.pins:type_name -> stream.video.sfu.models.Pin
 	3,  // 4: stream.video.sfu.models.Participant.published_tracks:type_name -> stream.video.sfu.models.TrackType
-	41, // 5: stream.video.sfu.models.Participant.joined_at:type_name -> google.protobuf.Timestamp
+	46, // 5: stream.video.sfu.models.Participant.joined_at:type_name -> google.protobuf.Timestamp
 	1,  // 6: stream.video.sfu.models.Participant.connection_quality:type_name -> stream.video.sfu.models.ConnectionQuality
-	42, // 7: stream.video.sfu.models.Participant.custom:type_name -> google.protobuf.Struct
+	47, // 7: stream.video.sfu.models.Participant.custom:type_name -> google.protobuf.Struct
 	4,  // 8: stream.video.sfu.models.Participant.source:type_name -> stream.video.sfu.models.ParticipantSource
 	2,  // 9: stream.video.sfu.models.StreamQuality.video_quality:type_name -> stream.video.sfu.models.VideoQuality
 	20, // 10: stream.video.sfu.models.VideoLayer.video_dimension:type_name -> stream.video.sfu.models.VideoDimension
@@ -3529,19 +4016,23 @@ var file_video_sfu_models_models_proto_depIdxs = []int32{
 	32, // 26: stream.video.sfu.models.ClientDetails.browser:type_name -> stream.video.sfu.models.Browser
 	34, // 27: stream.video.sfu.models.ClientDetails.device:type_name -> stream.video.sfu.models.Device
 	7,  // 28: stream.video.sfu.models.Sdk.type:type_name -> stream.video.sfu.models.SdkType
-	42, // 29: stream.video.sfu.models.Call.custom:type_name -> google.protobuf.Struct
-	41, // 30: stream.video.sfu.models.Call.created_at:type_name -> google.protobuf.Timestamp
-	41, // 31: stream.video.sfu.models.Call.updated_at:type_name -> google.protobuf.Timestamp
+	47, // 29: stream.video.sfu.models.Call.custom:type_name -> google.protobuf.Struct
+	46, // 30: stream.video.sfu.models.Call.created_at:type_name -> google.protobuf.Timestamp
+	46, // 31: stream.video.sfu.models.Call.updated_at:type_name -> google.protobuf.Timestamp
 	12, // 32: stream.video.sfu.models.AndroidState.thermal_state:type_name -> stream.video.sfu.models.AndroidThermalState
 	13, // 33: stream.video.sfu.models.AppleState.thermal_state:type_name -> stream.video.sfu.models.AppleThermalState
 	3,  // 34: stream.video.sfu.models.PerformanceStats.track_type:type_name -> stream.video.sfu.models.TrackType
 	24, // 35: stream.video.sfu.models.PerformanceStats.codec:type_name -> stream.video.sfu.models.Codec
 	20, // 36: stream.video.sfu.models.PerformanceStats.video_dimension:type_name -> stream.video.sfu.models.VideoDimension
-	37, // [37:37] is the sub-list for method output_type
-	37, // [37:37] is the sub-list for method input_type
-	37, // [37:37] is the sub-list for extension type_name
-	37, // [37:37] is the sub-list for extension extendee
-	0,  // [0:37] is the sub-list for field type_name
+	41, // 37: stream.video.sfu.models.InboundRtp.base:type_name -> stream.video.sfu.models.RtpBase
+	41, // 38: stream.video.sfu.models.OutboundRtp.base:type_name -> stream.video.sfu.models.RtpBase
+	41, // 39: stream.video.sfu.models.RemoteInboundRtp.base:type_name -> stream.video.sfu.models.RtpBase
+	41, // 40: stream.video.sfu.models.RemoteOutboundRtp.base:type_name -> stream.video.sfu.models.RtpBase
+	41, // [41:41] is the sub-list for method output_type
+	41, // [41:41] is the sub-list for method input_type
+	41, // [41:41] is the sub-list for extension type_name
+	41, // [41:41] is the sub-list for extension extendee
+	0,  // [0:41] is the sub-list for field type_name
 }
 
 func init() { file_video_sfu_models_models_proto_init() }
@@ -3862,6 +4353,66 @@ func file_video_sfu_models_models_proto_init() {
 				return nil
 			}
 		}
+		file_video_sfu_models_models_proto_msgTypes[26].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*RtpBase); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_video_sfu_models_models_proto_msgTypes[27].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*InboundRtp); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_video_sfu_models_models_proto_msgTypes[28].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*OutboundRtp); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_video_sfu_models_models_proto_msgTypes[29].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*RemoteInboundRtp); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_video_sfu_models_models_proto_msgTypes[30].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*RemoteOutboundRtp); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
 	}
 	type x struct{}
 	out := protoimpl.TypeBuilder{
@@ -3869,7 +4420,7 @@ func file_video_sfu_models_models_proto_init() {
 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
 			RawDescriptor: file_video_sfu_models_models_proto_rawDesc,
 			NumEnums:      15,
-			NumMessages:   26,
+			NumMessages:   31,
 			NumExtensions: 0,
 			NumServices:   0,
 		},
diff --git a/protobuf/video/sfu/models/models.proto b/protobuf/video/sfu/models/models.proto
index fc34873c7..bf5ec49d5 100644
--- a/protobuf/video/sfu/models/models.proto
+++ b/protobuf/video/sfu/models/models.proto
@@ -455,4 +455,67 @@ enum ClientCapability {
   CLIENT_CAPABILITY_SUBSCRIBER_VIDEO_PAUSE = 1;
   // Instructs SFU that stats will be sent to the coordinator
   CLIENT_CAPABILITY_COORDINATOR_STATS = 2;
-};
\ No newline at end of file
+};
+
+// ===================================================================
+// BASE (shared by all RTP directions)
+// ===================================================================
+message RtpBase {
+  uint32 ssrc         = 1; // raw stat["ssrc"]
+  string kind         = 2; // stat["kind"] ("audio","video")
+  double timestamp_ms = 3; // stat["timestamp"] in milliseconds
+}
+
+// ===================================================================
+// INBOUND (SUBSCRIBER RECEIVING MEDIA)
+// ===================================================================
+message InboundRtp {
+  RtpBase base = 1;
+
+  double jitter_seconds      = 2; // stat["jitter"]
+  uint64 packets_received    = 3; // stat["packetsReceived"]
+  uint64 packets_lost        = 4; // stat["packetsLost"]
+  double packet_loss_percent = 5; // (packets_lost / (packets_received + packets_lost)) * 100;skip if denominator <= 0 or counters decreased
+
+  // -------- AUDIO METRICS --------
+  uint32 concealment_events  = 10; // stat["concealmentEvents"]
+  double concealment_percent = 11; // (concealedSamples / totalSamplesReceived) * 100 when totalSamplesReceived >= 96_000 (≈2 s @ 48 kHz)
+
+  // -------- VIDEO METRICS --------
+  double fps                     = 20; // use delta(framesDecoded)/delta(time) with prev sample
+  double freeze_duration_seconds = 21; // stat["totalFreezesDuration"]
+  double avg_decode_time_seconds = 22; // stat["totalDecodeTime"] / max(1, stat["framesDecoded"])
+  uint32 min_dimension_px        = 23; // min(stat["frameWidth"], stat["frameHeight"]) for video-like tracks
+}
+
+// ===================================================================
+// OUTBOUND (PUBLISHER SENDING MEDIA)
+// ===================================================================
+message OutboundRtp {
+  RtpBase base = 1;
+
+  double fps                     = 10; // delta(framesEncoded)/delta(time) if missing
+  double avg_encode_time_seconds = 11; // stat["totalEncodeTime"] / max(1, stat["framesEncoded"])
+  double bitrate_bps             = 12; // delta(bytesSent)*8 / delta(timeSeconds); requires prev bytes/timestamp; ignore if delta<=0
+  uint32 min_dimension_px        = 13; // min(stat["frameWidth"], stat["frameHeight"])
+}
+
+// ===================================================================
+// SFU FEEDBACK: REMOTE-INBOUND (Publisher receives feedback)
+// ===================================================================
+message RemoteInboundRtp {
+  RtpBase base = 1;
+
+  double jitter_seconds    = 2; // stat["jitter"]
+  double round_trip_time_s = 3; // stat["roundTripTime"]
+}
+
+// ===================================================================
+// SFU FEEDBACK: REMOTE-OUTBOUND (Subscriber receives feedback)
+// ===================================================================
+message RemoteOutboundRtp {
+  RtpBase base = 1;
+
+  double jitter_seconds    = 2; // stat["jitter"] if provided
+  double round_trip_time_s = 3; // stat["roundTripTime"]
+}
diff --git a/protobuf/video/sfu/models/models_vtproto.pb.go b/protobuf/video/sfu/models/models_vtproto.pb.go
index c062945c1..85d2c3f20 100644
--- a/protobuf/video/sfu/models/models_vtproto.pb.go
+++ b/protobuf/video/sfu/models/models_vtproto.pb.go
@@ -1800,6 +1800,340 @@ func (m *PerformanceStats) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }
 
+func (m *RtpBase) MarshalVT() (dAtA []byte, err error) {
+	if m == nil {
+		return nil, nil
+	}
+	size := m.SizeVT()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *RtpBase) MarshalToVT(dAtA []byte) (int, error) {
+	size := m.SizeVT()
+	return m.MarshalToSizedBufferVT(dAtA[:size])
+}
+
+func (m *RtpBase) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
+	if m == nil {
+		return 0, nil
+	}
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.unknownFields != nil {
+		i -= len(m.unknownFields)
+		copy(dAtA[i:], m.unknownFields)
+	}
+	if m.TimestampMs != 0 {
+		i -= 8
+		binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.TimestampMs))))
+		i--
+		dAtA[i] = 0x19
+	}
+	if len(m.Kind) > 0 {
+		i -= len(m.Kind)
+		copy(dAtA[i:], m.Kind)
+		i = encodeVarint(dAtA, i, uint64(len(m.Kind)))
+		i--
+		dAtA[i] = 0x12
+	}
+	if m.Ssrc != 0 {
+		i = encodeVarint(dAtA, i, uint64(m.Ssrc))
+		i--
+		dAtA[i] = 0x8
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *InboundRtp) MarshalVT() (dAtA []byte, err error) {
+	if m == nil {
+		return nil, nil
+	}
+	size := m.SizeVT()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *InboundRtp) MarshalToVT(dAtA []byte) (int, error) {
+	size := m.SizeVT()
+	return m.MarshalToSizedBufferVT(dAtA[:size])
+}
+
+func (m *InboundRtp) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
+	if m == nil {
+		return 0, nil
+	}
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.unknownFields != nil {
+		i -= len(m.unknownFields)
+		copy(dAtA[i:], m.unknownFields)
+	}
+	if m.MinDimensionPx != 0 {
+		i = encodeVarint(dAtA, i, uint64(m.MinDimensionPx))
+		i--
+		dAtA[i] = 0x1
+		i--
+		dAtA[i] = 0xb8
+	}
+	if m.AvgDecodeTimeSeconds != 0 {
+		i -= 8
+		binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.AvgDecodeTimeSeconds))))
+		i--
+		dAtA[i] = 0x1
+		i--
+		dAtA[i] = 0xb1
+	}
+	if m.FreezeDurationSeconds != 0 {
+		i -= 8
+		binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.FreezeDurationSeconds))))
+		i--
+		dAtA[i] = 0x1
+		i--
+		dAtA[i] = 0xa9
+	}
+	if m.Fps != 0 {
+		i -= 8
+		binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Fps))))
+		i--
+		dAtA[i] = 0x1
+		i--
+		dAtA[i] = 0xa1
+	}
+	if m.ConcealmentPercent != 0 {
+		i -= 8
+		binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.ConcealmentPercent))))
+		i--
+		dAtA[i] = 0x59
+	}
+	if m.ConcealmentEvents != 0 {
+		i = encodeVarint(dAtA, i, uint64(m.ConcealmentEvents))
+		i--
+		dAtA[i] = 0x50
+	}
+	if m.PacketLossPercent != 0 {
+		i -= 8
+		binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.PacketLossPercent))))
+		i--
+		dAtA[i] = 0x29
+	}
+	if m.PacketsLost != 0 {
+		i = encodeVarint(dAtA, i, uint64(m.PacketsLost))
+		i--
+		dAtA[i] = 0x20
+	}
+	if m.PacketsReceived != 0 {
+		i = encodeVarint(dAtA, i, uint64(m.PacketsReceived))
+		i--
+		dAtA[i] = 0x18
+	}
+	if m.JitterSeconds != 0 {
+		i -= 8
+		binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.JitterSeconds))))
+		i--
+		dAtA[i] = 0x11
+	}
+	if m.Base != nil {
+		size, err := m.Base.MarshalToSizedBufferVT(dAtA[:i])
+		if err != nil {
+			return 0, err
+		}
+		i -= size
+		i = encodeVarint(dAtA, i, uint64(size))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *OutboundRtp) MarshalVT() (dAtA []byte, err error) {
+	if m == nil {
+		return nil, nil
+	}
+	size := m.SizeVT()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *OutboundRtp) MarshalToVT(dAtA []byte) (int, error) {
+	size := m.SizeVT()
+	return m.MarshalToSizedBufferVT(dAtA[:size])
+}
+
+func (m *OutboundRtp) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
+	if m == nil {
+		return 0, nil
+	}
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.unknownFields != nil {
+		i -= len(m.unknownFields)
+		copy(dAtA[i:], m.unknownFields)
+	}
+	if m.MinDimensionPx != 0 {
+		i = encodeVarint(dAtA, i, uint64(m.MinDimensionPx))
+		i--
+		dAtA[i] = 0x68
+	}
+	if m.BitrateBps != 0 {
+		i -= 8
+		binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.BitrateBps))))
+		i--
+		dAtA[i] = 0x61
+	}
+	if m.AvgEncodeTimeSeconds != 0 {
+		i -= 8
+		binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.AvgEncodeTimeSeconds))))
+		i--
+		dAtA[i] = 0x59
+	}
+	if m.Fps != 0 {
+		i -= 8
+		binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Fps))))
+		i--
+		dAtA[i] = 0x51
+	}
+	if m.Base != nil {
+		size, err := m.Base.MarshalToSizedBufferVT(dAtA[:i])
+		if err != nil {
+			return 0, err
+		}
+		i -= size
+		i = encodeVarint(dAtA, i, uint64(size))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *RemoteInboundRtp) MarshalVT() (dAtA []byte, err error) {
+	if m == nil {
+		return nil, nil
+	}
+	size := m.SizeVT()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *RemoteInboundRtp) MarshalToVT(dAtA []byte) (int, error) {
+	size := m.SizeVT()
+	return m.MarshalToSizedBufferVT(dAtA[:size])
+}
+
+func (m *RemoteInboundRtp) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
+	if m == nil {
+		return 0, nil
+	}
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.unknownFields != nil {
+		i -= len(m.unknownFields)
+		copy(dAtA[i:], m.unknownFields)
+	}
+	if m.RoundTripTimeS != 0 {
+		i -= 8
+		binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.RoundTripTimeS))))
+		i--
+		dAtA[i] = 0x19
+	}
+	if m.JitterSeconds != 0 {
+		i -= 8
+		binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.JitterSeconds))))
+		i--
+		dAtA[i] = 0x11
+	}
+	if m.Base != nil {
+		size, err := m.Base.MarshalToSizedBufferVT(dAtA[:i])
+		if err != nil {
+			return 0, err
+		}
+		i -= size
+		i = encodeVarint(dAtA, i, uint64(size))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *RemoteOutboundRtp) MarshalVT() (dAtA []byte, err error) {
+	if m == nil {
+		return nil, nil
+	}
+	size := m.SizeVT()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *RemoteOutboundRtp) MarshalToVT(dAtA []byte) (int, error) {
+	size := m.SizeVT()
+	return m.MarshalToSizedBufferVT(dAtA[:size])
+}
+
+func (m *RemoteOutboundRtp) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
+	if m == nil {
+		return 0, nil
+	}
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.unknownFields != nil {
+		i -= len(m.unknownFields)
+		copy(dAtA[i:], m.unknownFields)
+	}
+	if m.RoundTripTimeS != 0 {
+		i -= 8
+		binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.RoundTripTimeS))))
+		i--
+		dAtA[i] = 0x19
+	}
+	if m.JitterSeconds != 0 {
+		i -= 8
+		binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.JitterSeconds))))
+		i--
+		dAtA[i] = 0x11
+	}
+	if m.Base != nil {
+		size, err := m.Base.MarshalToSizedBufferVT(dAtA[:i])
+		if err != nil {
+			return 0, err
+		}
+		i -= size
+		i = encodeVarint(dAtA, i, uint64(size))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
 func encodeVarint(dAtA []byte, offset int, v uint64) int {
 	offset -= sov(v)
 	base := offset
@@ -2570,6 +2904,146 @@ func (m *PerformanceStats) SizeVT() (n int) {
 	return n
 }
 
+func (m *RtpBase) SizeVT() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.Ssrc != 0 {
+		n += 1 + sov(uint64(m.Ssrc))
+	}
+	l = len(m.Kind)
+	if l > 0 {
+		n += 1 + l + sov(uint64(l))
+	}
+	if m.TimestampMs != 0 {
+		n += 9
+	}
+	if m.unknownFields != nil {
+		n += len(m.unknownFields)
+	}
+	return n
+}
+
+func (m *InboundRtp) SizeVT() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.Base != nil {
+		l = m.Base.SizeVT()
+		n += 1 + l + sov(uint64(l))
+	}
+	if m.JitterSeconds != 0 {
+		n += 9
+	}
+	if m.PacketsReceived != 0 {
+		n += 1 + sov(uint64(m.PacketsReceived))
+	}
+	if m.PacketsLost != 0 {
+		n += 1 + sov(uint64(m.PacketsLost))
+	}
+	if m.PacketLossPercent != 0 {
+		n += 9
+	}
+	if m.ConcealmentEvents != 0 {
+		n += 1 + sov(uint64(m.ConcealmentEvents))
+	}
+	if m.ConcealmentPercent != 0 {
+		n += 9
+	}
+	if m.Fps != 0 {
+		n += 10
+	}
+	if m.FreezeDurationSeconds != 0 {
+		n += 10
+	}
+	if m.AvgDecodeTimeSeconds != 0 {
+		n += 10
+	}
+	if m.MinDimensionPx != 0 {
+		n += 2 + sov(uint64(m.MinDimensionPx))
+	}
+	if m.unknownFields != nil {
+		n += len(m.unknownFields)
+	}
+	return n
+}
+
+func (m *OutboundRtp) SizeVT() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.Base != nil {
+		l = m.Base.SizeVT()
+		n += 1 + l + sov(uint64(l))
+	}
+	if m.Fps != 0 {
+		n += 9
+	}
+	if m.AvgEncodeTimeSeconds != 0 {
+		n += 9
+	}
+	if m.BitrateBps != 0 {
+		n += 9
+	}
+	if m.MinDimensionPx != 0 {
+		n += 1 + sov(uint64(m.MinDimensionPx))
+	}
+	if m.unknownFields != nil {
+		n += len(m.unknownFields)
+	}
+	return n
+}
+
+func (m *RemoteInboundRtp) SizeVT() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.Base != nil {
+		l = m.Base.SizeVT()
+		n += 1 + l + sov(uint64(l))
+	}
+	if m.JitterSeconds != 0 {
+		n += 9
+	}
+	if m.RoundTripTimeS != 0 {
+		n += 9
+	}
+	if m.unknownFields != nil {
+		n += len(m.unknownFields)
+	}
+	return n
+}
+
+func (m *RemoteOutboundRtp) SizeVT() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.Base != nil {
+		l = m.Base.SizeVT()
+		n += 1 + l + sov(uint64(l))
+	}
+	if m.JitterSeconds != 0 {
+		n += 9
+	}
+	if m.RoundTripTimeS != 0 {
+		n += 9
+	}
+	if m.unknownFields != nil {
+		n += len(m.unknownFields)
+	}
+	return n
+}
+
 func sov(x uint64) (n int) {
 	return (bits.Len64(x|1) + 6) / 7
 }
@@ -6949,6 +7423,705 @@ func (m *PerformanceStats) UnmarshalVT(dAtA []byte) error {
 	}
 	return nil
 }
+func (m *RtpBase) UnmarshalVT(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflow
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: RtpBase: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: RtpBase: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Ssrc", wireType)
+			}
+			m.Ssrc = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Ssrc |= uint32(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLength
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLength
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Kind = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 3:
+			if wireType != 1 {
+				return fmt.Errorf("proto: wrong wireType = %d for field TimestampMs", wireType)
+			}
+			var v uint64
+			if (iNdEx + 8) > l {
+				return io.ErrUnexpectedEOF
+			}
+			v = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
+			iNdEx += 8
+			m.TimestampMs = float64(math.Float64frombits(v))
+		default:
+			iNdEx = preIndex
+			skippy, err := skip(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLength
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *InboundRtp) UnmarshalVT(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflow
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: InboundRtp: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: InboundRtp: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Base", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLength
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLength
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Base == nil {
+				m.Base = &RtpBase{}
+			}
+			if err := m.Base.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 1 {
+				return fmt.Errorf("proto: wrong wireType = %d for field JitterSeconds", wireType)
+			}
+			var v uint64
+			if (iNdEx + 8) > l {
+				return io.ErrUnexpectedEOF
+			}
+			v = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
+			iNdEx += 8
+			m.JitterSeconds = float64(math.Float64frombits(v))
+		case 3:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field PacketsReceived", wireType)
+			}
+			m.PacketsReceived = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.PacketsReceived |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 4:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field PacketsLost", wireType)
+			}
+			m.PacketsLost = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.PacketsLost |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 5:
+			if wireType != 1 {
+				return fmt.Errorf("proto: wrong wireType = %d for field PacketLossPercent", wireType)
+			}
+			var v uint64
+			if (iNdEx + 8) > l {
+				return io.ErrUnexpectedEOF
+			}
+			v = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
+			iNdEx += 8
+			m.PacketLossPercent = float64(math.Float64frombits(v))
+		case 10:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ConcealmentEvents", wireType)
+			}
+			m.ConcealmentEvents = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.ConcealmentEvents |= uint32(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 11:
+			if wireType != 1 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ConcealmentPercent", wireType)
+			}
+			var v uint64
+			if (iNdEx + 8) > l {
+				return io.ErrUnexpectedEOF
+			}
+			v = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
+			iNdEx += 8
+			m.ConcealmentPercent = float64(math.Float64frombits(v))
+		case 20:
+			if wireType != 1 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Fps", wireType)
+			}
+			var v uint64
+			if (iNdEx + 8) > l {
+				return io.ErrUnexpectedEOF
+			}
+			v = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
+			iNdEx += 8
+			m.Fps = float64(math.Float64frombits(v))
+		case 21:
+			if wireType != 1 {
+				return fmt.Errorf("proto: wrong wireType = %d for field FreezeDurationSeconds", wireType)
+			}
+			var v uint64
+			if (iNdEx + 8) > l {
+				return io.ErrUnexpectedEOF
+			}
+			v = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
+			iNdEx += 8
+			m.FreezeDurationSeconds = float64(math.Float64frombits(v))
+		case 22:
+			if wireType != 1 {
+				return fmt.Errorf("proto: wrong wireType = %d for field AvgDecodeTimeSeconds", wireType)
+			}
+			var v uint64
+			if (iNdEx + 8) > l {
+				return io.ErrUnexpectedEOF
+			}
+			v = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
+			iNdEx += 8
+			m.AvgDecodeTimeSeconds = float64(math.Float64frombits(v))
+		case 23:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field MinDimensionPx", wireType)
+			}
+			m.MinDimensionPx = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.MinDimensionPx |= uint32(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		default:
+			iNdEx = preIndex
+			skippy, err := skip(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLength
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *OutboundRtp) UnmarshalVT(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflow
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: OutboundRtp: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: OutboundRtp: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Base", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLength
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLength
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Base == nil {
+				m.Base = &RtpBase{}
+			}
+			if err := m.Base.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 10:
+			if wireType != 1 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Fps", wireType)
+			}
+			var v uint64
+			if (iNdEx + 8) > l {
+				return io.ErrUnexpectedEOF
+			}
+			v = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
+			iNdEx += 8
+			m.Fps = float64(math.Float64frombits(v))
+		case 11:
+			if wireType != 1 {
+				return fmt.Errorf("proto: wrong wireType = %d for field AvgEncodeTimeSeconds", wireType)
+			}
+			var v uint64
+			if (iNdEx + 8) > l {
+				return io.ErrUnexpectedEOF
+			}
+			v = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
+			iNdEx += 8
+			m.AvgEncodeTimeSeconds = float64(math.Float64frombits(v))
+		case 12:
+			if wireType != 1 {
+				return fmt.Errorf("proto: wrong wireType = %d for field BitrateBps", wireType)
+			}
+			var v uint64
+			if (iNdEx + 8) > l {
+				return io.ErrUnexpectedEOF
+			}
+			v = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
+			iNdEx += 8
+			m.BitrateBps = float64(math.Float64frombits(v))
+		case 13:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field MinDimensionPx", wireType)
+			}
+			m.MinDimensionPx = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.MinDimensionPx |= uint32(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		default:
+			iNdEx = preIndex
+			skippy, err := skip(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLength
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *RemoteInboundRtp) UnmarshalVT(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflow
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: RemoteInboundRtp: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: RemoteInboundRtp: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Base", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLength
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLength
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Base == nil {
+				m.Base = &RtpBase{}
+			}
+			if err := m.Base.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 1 {
+				return fmt.Errorf("proto: wrong wireType = %d for field JitterSeconds", wireType)
+			}
+			var v uint64
+			if (iNdEx + 8) > l {
+				return io.ErrUnexpectedEOF
+			}
+			v = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
+			iNdEx += 8
+			m.JitterSeconds = float64(math.Float64frombits(v))
+		case 3:
+			if wireType != 1 {
+				return fmt.Errorf("proto: wrong wireType = %d for field RoundTripTimeS", wireType)
+			}
+			var v uint64
+			if (iNdEx + 8) > l {
+				return io.ErrUnexpectedEOF
+			}
+			v = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
+			iNdEx += 8
+			m.RoundTripTimeS = float64(math.Float64frombits(v))
+		default:
+			iNdEx = preIndex
+			skippy, err := skip(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLength
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *RemoteOutboundRtp) UnmarshalVT(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflow
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: RemoteOutboundRtp: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: RemoteOutboundRtp: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Base", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLength
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLength
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Base == nil {
+				m.Base = &RtpBase{}
+			}
+			if err := m.Base.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 1 {
+				return fmt.Errorf("proto: wrong wireType = %d for field JitterSeconds", wireType)
+			}
+			var v uint64
+			if (iNdEx + 8) > l {
+				return io.ErrUnexpectedEOF
+			}
+			v = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
+			iNdEx += 8
+			m.JitterSeconds = float64(math.Float64frombits(v))
+		case 3:
+			if wireType != 1 {
+				return fmt.Errorf("proto: wrong wireType = %d for field RoundTripTimeS", wireType)
+			}
+			var v uint64
+			if (iNdEx + 8) > l {
+				return io.ErrUnexpectedEOF
+			}
+			v = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
+			iNdEx += 8
+			m.RoundTripTimeS = float64(math.Float64frombits(v))
+		default:
+			iNdEx = preIndex
+			skippy, err := skip(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLength
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
 func skip(dAtA []byte) (n int, err error) {
 	l := len(dAtA)
 	iNdEx := 0
diff --git a/protobuf/video/sfu/signal_rpc/signal.pb.go b/protobuf/video/sfu/signal_rpc/signal.pb.go
index 032234961..88e0ca414 100644
--- a/protobuf/video/sfu/signal_rpc/signal.pb.go
+++ b/protobuf/video/sfu/signal_rpc/signal.pb.go
@@ -345,6 +345,131 @@ func (*Telemetry_ConnectionTimeSeconds) isTelemetry_Data() {}
 
 func (*Telemetry_Reconnection) isTelemetry_Data() {}
 
+type SendMetricsRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	SessionId        string                      `protobuf:"bytes,1,opt,name=session_id,json=sessionId,proto3" json:"session_id,omitempty"`
+	UnifiedSessionId string                      `protobuf:"bytes,2,opt,name=unified_session_id,json=unifiedSessionId,proto3" json:"unified_session_id,omitempty"`
+	Inbounds         []*models.InboundRtp        `protobuf:"bytes,3,rep,name=inbounds,proto3" json:"inbounds,omitempty"`
+	Outbounds        []*models.OutboundRtp       `protobuf:"bytes,4,rep,name=outbounds,proto3" json:"outbounds,omitempty"`
+	RemoteInbounds   []*models.RemoteInboundRtp  `protobuf:"bytes,5,rep,name=remote_inbounds,json=remoteInbounds,proto3" json:"remote_inbounds,omitempty"`
+	RemoteOutbounds  []*models.RemoteOutboundRtp `protobuf:"bytes,6,rep,name=remote_outbounds,json=remoteOutbounds,proto3" json:"remote_outbounds,omitempty"`
+}
+
+func (x *SendMetricsRequest) Reset() {
+	*x = SendMetricsRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_video_sfu_signal_rpc_signal_proto_msgTypes[6]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *SendMetricsRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*SendMetricsRequest) ProtoMessage() {}
+
+func (x *SendMetricsRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_video_sfu_signal_rpc_signal_proto_msgTypes[6]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use SendMetricsRequest.ProtoReflect.Descriptor instead.
+func (*SendMetricsRequest) Descriptor() ([]byte, []int) {
+	return file_video_sfu_signal_rpc_signal_proto_rawDescGZIP(), []int{6}
+}
+
+func (x *SendMetricsRequest) GetSessionId() string {
+	if x != nil {
+		return x.SessionId
+	}
+	return ""
+}
+
+func (x *SendMetricsRequest) GetUnifiedSessionId() string {
+	if x != nil {
+		return x.UnifiedSessionId
+	}
+	return ""
+}
+
+func (x *SendMetricsRequest) GetInbounds() []*models.InboundRtp {
+	if x != nil {
+		return x.Inbounds
+	}
+	return nil
+}
+
+func (x *SendMetricsRequest) GetOutbounds() []*models.OutboundRtp {
+	if x != nil {
+		return x.Outbounds
+	}
+	return nil
+}
+
+func (x *SendMetricsRequest) GetRemoteInbounds() []*models.RemoteInboundRtp {
+	if x != nil {
+		return x.RemoteInbounds
+	}
+	return nil
+}
+
+func (x *SendMetricsRequest) GetRemoteOutbounds() []*models.RemoteOutboundRtp {
+	if x != nil {
+		return x.RemoteOutbounds
+	}
+	return nil
+}
+
+type SendMetricsResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *SendMetricsResponse) Reset() {
+	*x = SendMetricsResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_video_sfu_signal_rpc_signal_proto_msgTypes[7]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *SendMetricsResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*SendMetricsResponse) ProtoMessage() {}
+
+func (x *SendMetricsResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_video_sfu_signal_rpc_signal_proto_msgTypes[7]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use SendMetricsResponse.ProtoReflect.Descriptor instead.
+func (*SendMetricsResponse) Descriptor() ([]byte, []int) {
+	return file_video_sfu_signal_rpc_signal_proto_rawDescGZIP(), []int{7}
+}
+
 type SendStatsRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
@@ -383,7 +508,7 @@ type SendStatsRequest struct {
 func (x *SendStatsRequest) Reset() {
 	*x = SendStatsRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_video_sfu_signal_rpc_signal_proto_msgTypes[6]
+		mi := &file_video_sfu_signal_rpc_signal_proto_msgTypes[8]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -396,7 +521,7 @@ func (x *SendStatsRequest) String() string {
 func (*SendStatsRequest) ProtoMessage() {}
 
 func (x *SendStatsRequest) ProtoReflect() protoreflect.Message {
-	mi := &file_video_sfu_signal_rpc_signal_proto_msgTypes[6]
+	mi := &file_video_sfu_signal_rpc_signal_proto_msgTypes[8]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -409,7 +534,7 @@ func (x *SendStatsRequest) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use SendStatsRequest.ProtoReflect.Descriptor instead.
 func (*SendStatsRequest) Descriptor() ([]byte, []int) {
-	return file_video_sfu_signal_rpc_signal_proto_rawDescGZIP(), []int{6}
+	return file_video_sfu_signal_rpc_signal_proto_rawDescGZIP(), []int{8}
 }
 
 func (x *SendStatsRequest) GetSessionId() string {
@@ -574,7 +699,7 @@ type SendStatsResponse struct {
 func (x *SendStatsResponse) Reset() {
 	*x = SendStatsResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_video_sfu_signal_rpc_signal_proto_msgTypes[7]
+		mi := &file_video_sfu_signal_rpc_signal_proto_msgTypes[9]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -587,7 +712,7 @@ func (x *SendStatsResponse) String() string {
 func (*SendStatsResponse) ProtoMessage() {}
 
 func (x *SendStatsResponse) ProtoReflect() protoreflect.Message {
-	mi := &file_video_sfu_signal_rpc_signal_proto_msgTypes[7]
+	mi := &file_video_sfu_signal_rpc_signal_proto_msgTypes[9]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -600,7 +725,7 @@ func (x *SendStatsResponse) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use SendStatsResponse.ProtoReflect.Descriptor instead.
 func (*SendStatsResponse) Descriptor() ([]byte, []int) {
-	return file_video_sfu_signal_rpc_signal_proto_rawDescGZIP(), []int{7}
+	return file_video_sfu_signal_rpc_signal_proto_rawDescGZIP(), []int{9}
 }
 
 func (x *SendStatsResponse) GetError() *models.Error {
@@ -622,7 +747,7 @@ type ICERestartRequest struct {
 func (x *ICERestartRequest) Reset() {
 	*x = ICERestartRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_video_sfu_signal_rpc_signal_proto_msgTypes[8]
+		mi := &file_video_sfu_signal_rpc_signal_proto_msgTypes[10]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -635,7 +760,7 @@ func (x *ICERestartRequest) String() string {
 func (*ICERestartRequest) ProtoMessage() {}
 
 func (x *ICERestartRequest) ProtoReflect() protoreflect.Message {
-	mi := &file_video_sfu_signal_rpc_signal_proto_msgTypes[8]
+	mi := &file_video_sfu_signal_rpc_signal_proto_msgTypes[10]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -648,7 +773,7 @@ func (x *ICERestartRequest) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use ICERestartRequest.ProtoReflect.Descriptor instead.
 func (*ICERestartRequest) Descriptor() ([]byte, []int) {
-	return file_video_sfu_signal_rpc_signal_proto_rawDescGZIP(), []int{8}
+	return file_video_sfu_signal_rpc_signal_proto_rawDescGZIP(), []int{10}
 }
 
 func (x *ICERestartRequest) GetSessionId() string {
@@ -676,7 +801,7 @@ type ICERestartResponse struct {
 func (x *ICERestartResponse) Reset() {
 	*x = ICERestartResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_video_sfu_signal_rpc_signal_proto_msgTypes[9]
+		mi := &file_video_sfu_signal_rpc_signal_proto_msgTypes[11]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -689,7 +814,7 @@ func (x *ICERestartResponse) String() string {
 func (*ICERestartResponse) ProtoMessage() {}
 
 func (x *ICERestartResponse) ProtoReflect() protoreflect.Message {
-	mi := &file_video_sfu_signal_rpc_signal_proto_msgTypes[9]
+	mi := &file_video_sfu_signal_rpc_signal_proto_msgTypes[11]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -702,7 +827,7 @@ func (x *ICERestartResponse) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use ICERestartResponse.ProtoReflect.Descriptor instead.
 func (*ICERestartResponse) Descriptor() ([]byte, []int) {
-	return file_video_sfu_signal_rpc_signal_proto_rawDescGZIP(), []int{9}
+	return file_video_sfu_signal_rpc_signal_proto_rawDescGZIP(), []int{11}
 }
 
 func (x *ICERestartResponse) GetError() *models.Error {
@@ -724,7 +849,7 @@ type UpdateMuteStatesRequest struct {
 func (x *UpdateMuteStatesRequest) Reset() {
 	*x = UpdateMuteStatesRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_video_sfu_signal_rpc_signal_proto_msgTypes[10]
+		mi := &file_video_sfu_signal_rpc_signal_proto_msgTypes[12]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -737,7 +862,7 @@ func (x *UpdateMuteStatesRequest) String() string {
 func (*UpdateMuteStatesRequest) ProtoMessage() {}
 
 func (x *UpdateMuteStatesRequest) ProtoReflect() protoreflect.Message {
-	mi := &file_video_sfu_signal_rpc_signal_proto_msgTypes[10]
+	mi := &file_video_sfu_signal_rpc_signal_proto_msgTypes[12]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -750,7 +875,7 @@ func (x *UpdateMuteStatesRequest) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use UpdateMuteStatesRequest.ProtoReflect.Descriptor instead.
 func (*UpdateMuteStatesRequest) Descriptor() ([]byte, []int) {
-	return file_video_sfu_signal_rpc_signal_proto_rawDescGZIP(), []int{10}
+	return file_video_sfu_signal_rpc_signal_proto_rawDescGZIP(), []int{12}
 }
 
 func (x *UpdateMuteStatesRequest) GetSessionId() string {
@@ -778,7 +903,7 @@ type UpdateMuteStatesResponse struct {
 func (x *UpdateMuteStatesResponse) Reset() {
 	*x = UpdateMuteStatesResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_video_sfu_signal_rpc_signal_proto_msgTypes[11]
+		mi := &file_video_sfu_signal_rpc_signal_proto_msgTypes[13]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -791,7 +916,7 @@ func (x *UpdateMuteStatesResponse) String() string {
 func (*UpdateMuteStatesResponse) ProtoMessage() {}
 
 func (x *UpdateMuteStatesResponse) ProtoReflect() protoreflect.Message {
-	mi := &file_video_sfu_signal_rpc_signal_proto_msgTypes[11]
+	mi := &file_video_sfu_signal_rpc_signal_proto_msgTypes[13]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -804,7 +929,7 @@ func (x *UpdateMuteStatesResponse) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use UpdateMuteStatesResponse.ProtoReflect.Descriptor instead.
 func (*UpdateMuteStatesResponse) Descriptor() ([]byte, []int) {
-	return file_video_sfu_signal_rpc_signal_proto_rawDescGZIP(), []int{11}
+	return file_video_sfu_signal_rpc_signal_proto_rawDescGZIP(), []int{13}
 }
 
 func (x *UpdateMuteStatesResponse) GetError() *models.Error {
@@ -826,7 +951,7 @@ type TrackMuteState struct {
 func (x *TrackMuteState) Reset() {
 	*x = TrackMuteState{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_video_sfu_signal_rpc_signal_proto_msgTypes[12]
+		mi := &file_video_sfu_signal_rpc_signal_proto_msgTypes[14]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -839,7 +964,7 @@ func (x *TrackMuteState) String() string {
 func (*TrackMuteState) ProtoMessage() {}
 
 func (x *TrackMuteState) ProtoReflect() protoreflect.Message {
-	mi := &file_video_sfu_signal_rpc_signal_proto_msgTypes[12]
+	mi := &file_video_sfu_signal_rpc_signal_proto_msgTypes[14]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -852,7 +977,7 @@ func (x *TrackMuteState) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use TrackMuteState.ProtoReflect.Descriptor instead.
 func (*TrackMuteState) Descriptor() ([]byte, []int) {
-	return file_video_sfu_signal_rpc_signal_proto_rawDescGZIP(), []int{12}
+	return file_video_sfu_signal_rpc_signal_proto_rawDescGZIP(), []int{14}
 }
 
 func (x *TrackMuteState) GetTrackType() models.TrackType {
@@ -880,7 +1005,7 @@ type AudioMuteChanged struct {
 func (x *AudioMuteChanged) Reset() {
 	*x = AudioMuteChanged{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_video_sfu_signal_rpc_signal_proto_msgTypes[13]
+		mi := &file_video_sfu_signal_rpc_signal_proto_msgTypes[15]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -893,7 +1018,7 @@ func (x *AudioMuteChanged) String() string {
 func (*AudioMuteChanged) ProtoMessage() {}
 
 func (x *AudioMuteChanged) ProtoReflect() protoreflect.Message {
-	mi := &file_video_sfu_signal_rpc_signal_proto_msgTypes[13]
+	mi := &file_video_sfu_signal_rpc_signal_proto_msgTypes[15]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -906,7 +1031,7 @@ func (x *AudioMuteChanged) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use AudioMuteChanged.ProtoReflect.Descriptor instead.
 func (*AudioMuteChanged) Descriptor() ([]byte, []int) {
-	return file_video_sfu_signal_rpc_signal_proto_rawDescGZIP(), []int{13}
+	return file_video_sfu_signal_rpc_signal_proto_rawDescGZIP(), []int{15}
 }
 
 func (x *AudioMuteChanged) GetMuted() bool {
@@ -927,7 +1052,7 @@ type VideoMuteChanged struct {
 func (x *VideoMuteChanged) Reset() {
 	*x = VideoMuteChanged{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_video_sfu_signal_rpc_signal_proto_msgTypes[14]
+		mi := &file_video_sfu_signal_rpc_signal_proto_msgTypes[16]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -940,7 +1065,7 @@ func (x *VideoMuteChanged) String() string {
 func (*VideoMuteChanged) ProtoMessage() {}
 
 func (x *VideoMuteChanged) ProtoReflect() protoreflect.Message {
-	mi := &file_video_sfu_signal_rpc_signal_proto_msgTypes[14]
+	mi := &file_video_sfu_signal_rpc_signal_proto_msgTypes[16]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -953,7 +1078,7 @@ func (x *VideoMuteChanged) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use VideoMuteChanged.ProtoReflect.Descriptor instead.
 func (*VideoMuteChanged) Descriptor() ([]byte, []int) {
-	return file_video_sfu_signal_rpc_signal_proto_rawDescGZIP(), []int{14}
+	return file_video_sfu_signal_rpc_signal_proto_rawDescGZIP(), []int{16}
 }
 
 func (x *VideoMuteChanged) GetMuted() bool {
@@ -975,7 +1100,7 @@ type UpdateSubscriptionsRequest struct {
 func (x *UpdateSubscriptionsRequest) Reset() {
 	*x = UpdateSubscriptionsRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_video_sfu_signal_rpc_signal_proto_msgTypes[15]
+		mi := &file_video_sfu_signal_rpc_signal_proto_msgTypes[17]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -988,7 +1113,7 @@ func (x *UpdateSubscriptionsRequest) String() string {
 func (*UpdateSubscriptionsRequest) ProtoMessage() {}
 
 func (x *UpdateSubscriptionsRequest) ProtoReflect() protoreflect.Message {
-	mi := &file_video_sfu_signal_rpc_signal_proto_msgTypes[15]
+	mi := &file_video_sfu_signal_rpc_signal_proto_msgTypes[17]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -1001,7 +1126,7 @@ func (x *UpdateSubscriptionsRequest) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use UpdateSubscriptionsRequest.ProtoReflect.Descriptor instead.
 func (*UpdateSubscriptionsRequest) Descriptor() ([]byte, []int) {
-	return file_video_sfu_signal_rpc_signal_proto_rawDescGZIP(), []int{15}
+	return file_video_sfu_signal_rpc_signal_proto_rawDescGZIP(), []int{17}
 }
 
 func (x *UpdateSubscriptionsRequest) GetSessionId() string {
@@ -1029,7 +1154,7 @@ type UpdateSubscriptionsResponse struct {
 func (x *UpdateSubscriptionsResponse) Reset() {
 	*x = UpdateSubscriptionsResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_video_sfu_signal_rpc_signal_proto_msgTypes[16]
+		mi := &file_video_sfu_signal_rpc_signal_proto_msgTypes[18]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -1042,7 +1167,7 @@ func (x *UpdateSubscriptionsResponse) String() string {
 func (*UpdateSubscriptionsResponse) ProtoMessage() {}
 
 func (x *UpdateSubscriptionsResponse) ProtoReflect() protoreflect.Message {
-	mi := &file_video_sfu_signal_rpc_signal_proto_msgTypes[16]
+	mi := &file_video_sfu_signal_rpc_signal_proto_msgTypes[18]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -1055,7 +1180,7 @@ func (x *UpdateSubscriptionsResponse) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use UpdateSubscriptionsResponse.ProtoReflect.Descriptor instead.
 func (*UpdateSubscriptionsResponse) Descriptor() ([]byte, []int) {
-	return file_video_sfu_signal_rpc_signal_proto_rawDescGZIP(), []int{16}
+	return file_video_sfu_signal_rpc_signal_proto_rawDescGZIP(), []int{18}
 }
 
 func (x *UpdateSubscriptionsResponse) GetError() *models.Error {
@@ -1079,7 +1204,7 @@ type TrackSubscriptionDetails struct {
 func (x *TrackSubscriptionDetails) Reset() {
 	*x = TrackSubscriptionDetails{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_video_sfu_signal_rpc_signal_proto_msgTypes[17]
+		mi := &file_video_sfu_signal_rpc_signal_proto_msgTypes[19]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -1092,7 +1217,7 @@ func (x *TrackSubscriptionDetails) String() string {
 func (*TrackSubscriptionDetails) ProtoMessage() {}
 
 func (x *TrackSubscriptionDetails) ProtoReflect() protoreflect.Message {
-	mi := &file_video_sfu_signal_rpc_signal_proto_msgTypes[17]
+	mi := &file_video_sfu_signal_rpc_signal_proto_msgTypes[19]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -1105,7 +1230,7 @@ func (x *TrackSubscriptionDetails) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use TrackSubscriptionDetails.ProtoReflect.Descriptor instead.
 func (*TrackSubscriptionDetails) Descriptor() ([]byte, []int) {
-	return file_video_sfu_signal_rpc_signal_proto_rawDescGZIP(), []int{17}
+	return file_video_sfu_signal_rpc_signal_proto_rawDescGZIP(), []int{19}
 }
 
 func (x *TrackSubscriptionDetails) GetUserId() string {
@@ -1149,7 +1274,7 @@ type SendAnswerRequest struct {
 func (x *SendAnswerRequest) Reset() {
 	*x = SendAnswerRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_video_sfu_signal_rpc_signal_proto_msgTypes[18]
+		mi := &file_video_sfu_signal_rpc_signal_proto_msgTypes[20]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -1162,7 +1287,7 @@ func (x *SendAnswerRequest) String() string {
 func (*SendAnswerRequest) ProtoMessage() {}
 
 func (x *SendAnswerRequest) ProtoReflect() protoreflect.Message {
-	mi := &file_video_sfu_signal_rpc_signal_proto_msgTypes[18]
+	mi := &file_video_sfu_signal_rpc_signal_proto_msgTypes[20]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -1175,7 +1300,7 @@ func (x *SendAnswerRequest) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use SendAnswerRequest.ProtoReflect.Descriptor instead.
 func (*SendAnswerRequest) Descriptor() ([]byte, []int) {
-	return file_video_sfu_signal_rpc_signal_proto_rawDescGZIP(), []int{18}
+	return file_video_sfu_signal_rpc_signal_proto_rawDescGZIP(), []int{20}
 }
 
 func (x *SendAnswerRequest) GetPeerType() models.PeerType {
@@ -1210,7 +1335,7 @@ type SendAnswerResponse struct {
 func (x *SendAnswerResponse) Reset() {
 	*x = SendAnswerResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_video_sfu_signal_rpc_signal_proto_msgTypes[19]
+		mi := &file_video_sfu_signal_rpc_signal_proto_msgTypes[21]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -1223,7 +1348,7 @@ func (x *SendAnswerResponse) String() string {
 func (*SendAnswerResponse) ProtoMessage() {}
 
 func (x *SendAnswerResponse) ProtoReflect() protoreflect.Message {
-	mi := &file_video_sfu_signal_rpc_signal_proto_msgTypes[19]
+	mi := &file_video_sfu_signal_rpc_signal_proto_msgTypes[21]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -1236,7 +1361,7 @@ func (x *SendAnswerResponse) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use SendAnswerResponse.ProtoReflect.Descriptor instead.
 func (*SendAnswerResponse) Descriptor() ([]byte, []int) {
-	return file_video_sfu_signal_rpc_signal_proto_rawDescGZIP(), []int{19}
+	return file_video_sfu_signal_rpc_signal_proto_rawDescGZIP(), []int{21}
 }
 
 func (x *SendAnswerResponse) GetError() *models.Error {
@@ -1257,7 +1382,7 @@ type ICETrickleResponse struct {
 func (x *ICETrickleResponse) Reset() {
 	*x = ICETrickleResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_video_sfu_signal_rpc_signal_proto_msgTypes[20]
+		mi := &file_video_sfu_signal_rpc_signal_proto_msgTypes[22]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -1270,7 +1395,7 @@ func (x *ICETrickleResponse) String() string {
 func (*ICETrickleResponse) ProtoMessage() {}
 
 func (x *ICETrickleResponse) ProtoReflect() protoreflect.Message {
-	mi := &file_video_sfu_signal_rpc_signal_proto_msgTypes[20]
+	mi := &file_video_sfu_signal_rpc_signal_proto_msgTypes[22]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -1283,7 +1408,7 @@ func (x *ICETrickleResponse) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use ICETrickleResponse.ProtoReflect.Descriptor instead.
 func (*ICETrickleResponse) Descriptor() ([]byte, []int) {
-	return file_video_sfu_signal_rpc_signal_proto_rawDescGZIP(), []int{20}
+	return file_video_sfu_signal_rpc_signal_proto_rawDescGZIP(), []int{22}
 }
 
 func (x *ICETrickleResponse) GetError() *models.Error {
@@ -1307,7 +1432,7 @@ type SetPublisherRequest struct {
 func (x *SetPublisherRequest) Reset() {
 	*x = SetPublisherRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_video_sfu_signal_rpc_signal_proto_msgTypes[21]
+		mi := &file_video_sfu_signal_rpc_signal_proto_msgTypes[23]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -1320,7 +1445,7 @@ func (x *SetPublisherRequest) String() string {
 func (*SetPublisherRequest) ProtoMessage() {}
 
 func (x *SetPublisherRequest) ProtoReflect() protoreflect.Message {
-	mi := &file_video_sfu_signal_rpc_signal_proto_msgTypes[21]
+	mi := &file_video_sfu_signal_rpc_signal_proto_msgTypes[23]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -1333,7 +1458,7 @@ func (x *SetPublisherRequest) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use SetPublisherRequest.ProtoReflect.Descriptor instead.
 func (*SetPublisherRequest) Descriptor() ([]byte, []int) {
-	return file_video_sfu_signal_rpc_signal_proto_rawDescGZIP(), []int{21}
+	return file_video_sfu_signal_rpc_signal_proto_rawDescGZIP(), []int{23}
 }
 
 func (x *SetPublisherRequest) GetSdp() string {
@@ -1372,7 +1497,7 @@ type SetPublisherResponse struct {
 func (x *SetPublisherResponse) Reset() {
 	*x = SetPublisherResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_video_sfu_signal_rpc_signal_proto_msgTypes[22]
+		mi := &file_video_sfu_signal_rpc_signal_proto_msgTypes[24]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -1385,7 +1510,7 @@ func (x *SetPublisherResponse) String() string {
 func (*SetPublisherResponse) ProtoMessage() {}
 
 func (x *SetPublisherResponse) ProtoReflect() protoreflect.Message {
-	mi := &file_video_sfu_signal_rpc_signal_proto_msgTypes[22]
+	mi := &file_video_sfu_signal_rpc_signal_proto_msgTypes[24]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -1398,7 +1523,7 @@ func (x *SetPublisherResponse) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use SetPublisherResponse.ProtoReflect.Descriptor instead.
 func (*SetPublisherResponse) Descriptor() ([]byte, []int) {
-	return file_video_sfu_signal_rpc_signal_proto_rawDescGZIP(), []int{22}
+	return file_video_sfu_signal_rpc_signal_proto_rawDescGZIP(), []int{24}
 }
 
 func (x *SetPublisherResponse) GetSdp() string {
@@ -1474,248 +1599,281 @@ var file_video_sfu_signal_rpc_signal_proto_rawDesc = []byte{
 	0x74, 0x72, 0x65, 0x61, 0x6d, 0x2e, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x2e, 0x73, 0x66, 0x75, 0x2e,
 	0x73, 0x69, 0x67, 0x6e, 0x61, 0x6c, 0x2e, 0x52, 0x65, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74,
 	0x69, 0x6f, 0x6e, 0x48, 0x00, 0x52, 0x0c, 0x72, 0x65, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74,
-	0x69, 0x6f, 0x6e, 0x42, 0x06, 0x0a, 0x04, 0x64, 0x61, 0x74, 0x61, 0x22, 0xd4, 0x07, 0x0a, 0x10,
-	0x53, 0x65, 0x6e, 0x64, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
-	0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01,
-	0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x12,
-	0x29, 0x0a, 0x10, 0x73, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x72, 0x5f, 0x73, 0x74,
-	0x61, 0x74, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x73, 0x75, 0x62, 0x73, 0x63,
-	0x72, 0x69, 0x62, 0x65, 0x72, 0x53, 0x74, 0x61, 0x74, 0x73, 0x12, 0x27, 0x0a, 0x0f, 0x70, 0x75,
-	0x62, 0x6c, 0x69, 0x73, 0x68, 0x65, 0x72, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x73, 0x18, 0x03, 0x20,
-	0x01, 0x28, 0x09, 0x52, 0x0e, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x65, 0x72, 0x53, 0x74,
-	0x61, 0x74, 0x73, 0x12, 0x25, 0x0a, 0x0e, 0x77, 0x65, 0x62, 0x72, 0x74, 0x63, 0x5f, 0x76, 0x65,
-	0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x77, 0x65, 0x62,
-	0x72, 0x74, 0x63, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x10, 0x0a, 0x03, 0x73, 0x64,
-	0x6b, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x73, 0x64, 0x6b, 0x12, 0x1f, 0x0a, 0x0b,
-	0x73, 0x64, 0x6b, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x06, 0x20, 0x01, 0x28,
-	0x09, 0x52, 0x0a, 0x73, 0x64, 0x6b, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x4a, 0x0a,
-	0x0d, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x5f, 0x64, 0x65, 0x76, 0x69, 0x63, 0x65, 0x73, 0x18, 0x07,
-	0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x2e, 0x76, 0x69,
-	0x64, 0x65, 0x6f, 0x2e, 0x73, 0x66, 0x75, 0x2e, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x73, 0x2e, 0x49,
-	0x6e, 0x70, 0x75, 0x74, 0x44, 0x65, 0x76, 0x69, 0x63, 0x65, 0x73, 0x52, 0x0c, 0x61, 0x75, 0x64,
-	0x69, 0x6f, 0x44, 0x65, 0x76, 0x69, 0x63, 0x65, 0x73, 0x12, 0x4a, 0x0a, 0x0d, 0x76, 0x69, 0x64,
-	0x65, 0x6f, 0x5f, 0x64, 0x65, 0x76, 0x69, 0x63, 0x65, 0x73, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b,
-	0x32, 0x25, 0x2e, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x2e, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x2e,
-	0x73, 0x66, 0x75, 0x2e, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x73, 0x2e, 0x49, 0x6e, 0x70, 0x75, 0x74,
-	0x44, 0x65, 0x76, 0x69, 0x63, 0x65, 0x73, 0x52, 0x0c, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x44, 0x65,
-	0x76, 0x69, 0x63, 0x65, 0x73, 0x12, 0x41, 0x0a, 0x07, 0x61, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64,
-	0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x2e,
-	0x76, 0x69, 0x64, 0x65, 0x6f, 0x2e, 0x73, 0x66, 0x75, 0x2e, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x73,
-	0x2e, 0x41, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x53, 0x74, 0x61, 0x74, 0x65, 0x48, 0x00, 0x52,
-	0x07, 0x61, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x12, 0x3b, 0x0a, 0x05, 0x61, 0x70, 0x70, 0x6c,
-	0x65, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d,
+	0x69, 0x6f, 0x6e, 0x42, 0x06, 0x0a, 0x04, 0x64, 0x61, 0x74, 0x61, 0x22, 0x91, 0x03, 0x0a, 0x12,
+	0x53, 0x65, 0x6e, 0x64, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65,
+	0x73, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x49,
+	0x64, 0x12, 0x2c, 0x0a, 0x12, 0x75, 0x6e, 0x69, 0x66, 0x69, 0x65, 0x64, 0x5f, 0x73, 0x65, 0x73,
+	0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x10, 0x75,
+	0x6e, 0x69, 0x66, 0x69, 0x65, 0x64, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x12,
+	0x3f, 0x0a, 0x08, 0x69, 0x6e, 0x62, 0x6f, 0x75, 0x6e, 0x64, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28,
+	0x0b, 0x32, 0x23, 0x2e, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x2e, 0x76, 0x69, 0x64, 0x65, 0x6f,
+	0x2e, 0x73, 0x66, 0x75, 0x2e, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x73, 0x2e, 0x49, 0x6e, 0x62, 0x6f,
+	0x75, 0x6e, 0x64, 0x52, 0x74, 0x70, 0x52, 0x08, 0x69, 0x6e, 0x62, 0x6f, 0x75, 0x6e, 0x64, 0x73,
+	0x12, 0x42, 0x0a, 0x09, 0x6f, 0x75, 0x74, 0x62, 0x6f, 0x75, 0x6e, 0x64, 0x73, 0x18, 0x04, 0x20,
+	0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x2e, 0x76, 0x69, 0x64,
+	0x65, 0x6f, 0x2e, 0x73, 0x66, 0x75, 0x2e, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x73, 0x2e, 0x4f, 0x75,
+	0x74, 0x62, 0x6f, 0x75, 0x6e, 0x64, 0x52, 0x74, 0x70, 0x52, 0x09, 0x6f, 0x75, 0x74, 0x62, 0x6f,
+	0x75, 0x6e, 0x64, 0x73, 0x12, 0x52, 0x0a, 0x0f, 0x72, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x5f, 0x69,
+	0x6e, 0x62, 0x6f, 0x75, 0x6e, 0x64, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x29, 0x2e,
+	0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x2e, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x2e, 0x73, 0x66, 0x75,
+	0x2e, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x73, 0x2e, 0x52, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x49, 0x6e,
+	0x62, 0x6f, 0x75, 0x6e, 0x64, 0x52, 0x74, 0x70, 0x52, 0x0e, 0x72, 0x65, 0x6d, 0x6f, 0x74, 0x65,
+	0x49, 0x6e, 0x62, 0x6f, 0x75, 0x6e, 0x64, 0x73, 0x12, 0x55, 0x0a, 0x10, 0x72, 0x65, 0x6d, 0x6f,
+	0x74, 0x65, 0x5f, 0x6f, 0x75, 0x74, 0x62, 0x6f, 0x75, 0x6e, 0x64, 0x73, 0x18, 0x06, 0x20, 0x03,
+	0x28, 0x0b, 0x32, 0x2a, 0x2e, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x2e, 0x76, 0x69, 0x64, 0x65,
+	0x6f, 0x2e, 0x73, 0x66, 0x75, 0x2e, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x73, 0x2e, 0x52, 0x65, 0x6d,
+	0x6f, 0x74, 0x65, 0x4f, 0x75, 0x74, 0x62, 0x6f, 0x75, 0x6e, 0x64, 0x52, 0x74, 0x70, 0x52, 0x0f,
+	0x72, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x4f, 0x75, 0x74, 0x62, 0x6f, 0x75, 0x6e, 0x64, 0x73, 0x22,
+	0x15, 0x0a, 0x13, 0x53, 0x65, 0x6e, 0x64, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x52, 0x65,
+	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0xd4, 0x07, 0x0a, 0x10, 0x53, 0x65, 0x6e, 0x64, 0x53,
+	0x74, 0x61, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x73,
+	0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x09, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x12, 0x29, 0x0a, 0x10, 0x73, 0x75,
+	0x62, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x72, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x73, 0x18, 0x02,
+	0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x73, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x72,
+	0x53, 0x74, 0x61, 0x74, 0x73, 0x12, 0x27, 0x0a, 0x0f, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68,
+	0x65, 0x72, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e,
+	0x70, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x65, 0x72, 0x53, 0x74, 0x61, 0x74, 0x73, 0x12, 0x25,
+	0x0a, 0x0e, 0x77, 0x65, 0x62, 0x72, 0x74, 0x63, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e,
+	0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x77, 0x65, 0x62, 0x72, 0x74, 0x63, 0x56, 0x65,
+	0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x10, 0x0a, 0x03, 0x73, 0x64, 0x6b, 0x18, 0x05, 0x20, 0x01,
+	0x28, 0x09, 0x52, 0x03, 0x73, 0x64, 0x6b, 0x12, 0x1f, 0x0a, 0x0b, 0x73, 0x64, 0x6b, 0x5f, 0x76,
+	0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x73, 0x64,
+	0x6b, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x4a, 0x0a, 0x0d, 0x61, 0x75, 0x64, 0x69,
+	0x6f, 0x5f, 0x64, 0x65, 0x76, 0x69, 0x63, 0x65, 0x73, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32,
+	0x25, 0x2e, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x2e, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x2e, 0x73,
+	0x66, 0x75, 0x2e, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x73, 0x2e, 0x49, 0x6e, 0x70, 0x75, 0x74, 0x44,
+	0x65, 0x76, 0x69, 0x63, 0x65, 0x73, 0x52, 0x0c, 0x61, 0x75, 0x64, 0x69, 0x6f, 0x44, 0x65, 0x76,
+	0x69, 0x63, 0x65, 0x73, 0x12, 0x4a, 0x0a, 0x0d, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x5f, 0x64, 0x65,
+	0x76, 0x69, 0x63, 0x65, 0x73, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x73, 0x74,
+	0x72, 0x65, 0x61, 0x6d, 0x2e, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x2e, 0x73, 0x66, 0x75, 0x2e, 0x6d,
+	0x6f, 0x64, 0x65, 0x6c, 0x73, 0x2e, 0x49, 0x6e, 0x70, 0x75, 0x74, 0x44, 0x65, 0x76, 0x69, 0x63,
+	0x65, 0x73, 0x52, 0x0c, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x44, 0x65, 0x76, 0x69, 0x63, 0x65, 0x73,
+	0x12, 0x41, 0x0a, 0x07, 0x61, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x18, 0x09, 0x20, 0x01, 0x28,
+	0x0b, 0x32, 0x25, 0x2e, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x2e, 0x76, 0x69, 0x64, 0x65, 0x6f,
+	0x2e, 0x73, 0x66, 0x75, 0x2e, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x73, 0x2e, 0x41, 0x6e, 0x64, 0x72,
+	0x6f, 0x69, 0x64, 0x53, 0x74, 0x61, 0x74, 0x65, 0x48, 0x00, 0x52, 0x07, 0x61, 0x6e, 0x64, 0x72,
+	0x6f, 0x69, 0x64, 0x12, 0x3b, 0x0a, 0x05, 0x61, 0x70, 0x70, 0x6c, 0x65, 0x18, 0x0a, 0x20, 0x01,
+	0x28, 0x0b, 0x32, 0x23, 0x2e, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x2e, 0x76, 0x69, 0x64, 0x65,
+	0x6f, 0x2e, 0x73, 0x66, 0x75, 0x2e, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x73, 0x2e, 0x41, 0x70, 0x70,
+	0x6c, 0x65, 0x53, 0x74, 0x61, 0x74, 0x65, 0x48, 0x00, 0x52, 0x05, 0x61, 0x70, 0x70, 0x6c, 0x65,
+	0x12, 0x40, 0x0a, 0x09, 0x74, 0x65, 0x6c, 0x65, 0x6d, 0x65, 0x74, 0x72, 0x79, 0x18, 0x0b, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x2e, 0x76, 0x69, 0x64,
+	0x65, 0x6f, 0x2e, 0x73, 0x66, 0x75, 0x2e, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x6c, 0x2e, 0x54, 0x65,
+	0x6c, 0x65, 0x6d, 0x65, 0x74, 0x72, 0x79, 0x52, 0x09, 0x74, 0x65, 0x6c, 0x65, 0x6d, 0x65, 0x74,
+	0x72, 0x79, 0x12, 0x38, 0x0a, 0x04, 0x72, 0x74, 0x6d, 0x70, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0b,
+	0x32, 0x24, 0x2e, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x2e, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x2e,
+	0x73, 0x66, 0x75, 0x2e, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x73, 0x2e, 0x52, 0x54, 0x4d, 0x50, 0x49,
+	0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, 0x52, 0x04, 0x72, 0x74, 0x6d, 0x70, 0x12, 0x34, 0x0a, 0x14,
+	0x73, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x72, 0x5f, 0x72, 0x74, 0x63, 0x5f, 0x73,
+	0x74, 0x61, 0x74, 0x73, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x09, 0x42, 0x02, 0x18, 0x01, 0x52, 0x12,
+	0x73, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x72, 0x52, 0x74, 0x63, 0x53, 0x74, 0x61,
+	0x74, 0x73, 0x12, 0x32, 0x0a, 0x13, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x65, 0x72, 0x5f,
+	0x72, 0x74, 0x63, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x73, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x09, 0x42,
+	0x02, 0x18, 0x01, 0x52, 0x11, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x65, 0x72, 0x52, 0x74,
+	0x63, 0x53, 0x74, 0x61, 0x74, 0x73, 0x12, 0x1b, 0x0a, 0x09, 0x72, 0x74, 0x63, 0x5f, 0x73, 0x74,
+	0x61, 0x74, 0x73, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x72, 0x74, 0x63, 0x53, 0x74,
+	0x61, 0x74, 0x73, 0x12, 0x4c, 0x0a, 0x0c, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x5f, 0x73, 0x74,
+	0x61, 0x74, 0x73, 0x18, 0x10, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x29, 0x2e, 0x73, 0x74, 0x72, 0x65,
+	0x61, 0x6d, 0x2e, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x2e, 0x73, 0x66, 0x75, 0x2e, 0x6d, 0x6f, 0x64,
+	0x65, 0x6c, 0x73, 0x2e, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x6e, 0x63, 0x65, 0x53,
+	0x74, 0x61, 0x74, 0x73, 0x52, 0x0b, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x53, 0x74, 0x61, 0x74,
+	0x73, 0x12, 0x4c, 0x0a, 0x0c, 0x64, 0x65, 0x63, 0x6f, 0x64, 0x65, 0x5f, 0x73, 0x74, 0x61, 0x74,
+	0x73, 0x18, 0x11, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x29, 0x2e, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d,
 	0x2e, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x2e, 0x73, 0x66, 0x75, 0x2e, 0x6d, 0x6f, 0x64, 0x65, 0x6c,
-	0x73, 0x2e, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x53, 0x74, 0x61, 0x74, 0x65, 0x48, 0x00, 0x52, 0x05,
-	0x61, 0x70, 0x70, 0x6c, 0x65, 0x12, 0x40, 0x0a, 0x09, 0x74, 0x65, 0x6c, 0x65, 0x6d, 0x65, 0x74,
-	0x72, 0x79, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x73, 0x74, 0x72, 0x65, 0x61,
+	0x73, 0x2e, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x6e, 0x63, 0x65, 0x53, 0x74, 0x61,
+	0x74, 0x73, 0x52, 0x0b, 0x64, 0x65, 0x63, 0x6f, 0x64, 0x65, 0x53, 0x74, 0x61, 0x74, 0x73, 0x12,
+	0x2c, 0x0a, 0x12, 0x75, 0x6e, 0x69, 0x66, 0x69, 0x65, 0x64, 0x5f, 0x73, 0x65, 0x73, 0x73, 0x69,
+	0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x12, 0x20, 0x01, 0x28, 0x09, 0x52, 0x10, 0x75, 0x6e, 0x69,
+	0x66, 0x69, 0x65, 0x64, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x42, 0x0e, 0x0a,
+	0x0c, 0x64, 0x65, 0x76, 0x69, 0x63, 0x65, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x65, 0x22, 0x49, 0x0a,
+	0x11, 0x53, 0x65, 0x6e, 0x64, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
+	0x73, 0x65, 0x12, 0x34, 0x0a, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28,
+	0x0b, 0x32, 0x1e, 0x2e, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x2e, 0x76, 0x69, 0x64, 0x65, 0x6f,
+	0x2e, 0x73, 0x66, 0x75, 0x2e, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x73, 0x2e, 0x45, 0x72, 0x72, 0x6f,
+	0x72, 0x52, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x22, 0x72, 0x0a, 0x11, 0x49, 0x43, 0x45, 0x52,
+	0x65, 0x73, 0x74, 0x61, 0x72, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1d, 0x0a,
+	0x0a, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x09, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x12, 0x3e, 0x0a, 0x09,
+	0x70, 0x65, 0x65, 0x72, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32,
+	0x21, 0x2e, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x2e, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x2e, 0x73,
+	0x66, 0x75, 0x2e, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x73, 0x2e, 0x50, 0x65, 0x65, 0x72, 0x54, 0x79,
+	0x70, 0x65, 0x52, 0x08, 0x70, 0x65, 0x65, 0x72, 0x54, 0x79, 0x70, 0x65, 0x22, 0x4a, 0x0a, 0x12,
+	0x49, 0x43, 0x45, 0x52, 0x65, 0x73, 0x74, 0x61, 0x72, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
+	0x73, 0x65, 0x12, 0x34, 0x0a, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28,
+	0x0b, 0x32, 0x1e, 0x2e, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x2e, 0x76, 0x69, 0x64, 0x65, 0x6f,
+	0x2e, 0x73, 0x66, 0x75, 0x2e, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x73, 0x2e, 0x45, 0x72, 0x72, 0x6f,
+	0x72, 0x52, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x22, 0x82, 0x01, 0x0a, 0x17, 0x55, 0x70, 0x64,
+	0x61, 0x74, 0x65, 0x4d, 0x75, 0x74, 0x65, 0x53, 0x74, 0x61, 0x74, 0x65, 0x73, 0x52, 0x65, 0x71,
+	0x75, 0x65, 0x73, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x5f,
+	0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f,
+	0x6e, 0x49, 0x64, 0x12, 0x48, 0x0a, 0x0b, 0x6d, 0x75, 0x74, 0x65, 0x5f, 0x73, 0x74, 0x61, 0x74,
+	0x65, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x73, 0x74, 0x72, 0x65, 0x61,
 	0x6d, 0x2e, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x2e, 0x73, 0x66, 0x75, 0x2e, 0x73, 0x69, 0x67, 0x6e,
-	0x61, 0x6c, 0x2e, 0x54, 0x65, 0x6c, 0x65, 0x6d, 0x65, 0x74, 0x72, 0x79, 0x52, 0x09, 0x74, 0x65,
-	0x6c, 0x65, 0x6d, 0x65, 0x74, 0x72, 0x79, 0x12, 0x38, 0x0a, 0x04, 0x72, 0x74, 0x6d, 0x70, 0x18,
-	0x0c, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x2e, 0x76,
+	0x61, 0x6c, 0x2e, 0x54, 0x72, 0x61, 0x63, 0x6b, 0x4d, 0x75, 0x74, 0x65, 0x53, 0x74, 0x61, 0x74,
+	0x65, 0x52, 0x0a, 0x6d, 0x75, 0x74, 0x65, 0x53, 0x74, 0x61, 0x74, 0x65, 0x73, 0x22, 0x50, 0x0a,
+	0x18, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x4d, 0x75, 0x74, 0x65, 0x53, 0x74, 0x61, 0x74, 0x65,
+	0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x34, 0x0a, 0x05, 0x65, 0x72, 0x72,
+	0x6f, 0x72, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x73, 0x74, 0x72, 0x65, 0x61,
+	0x6d, 0x2e, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x2e, 0x73, 0x66, 0x75, 0x2e, 0x6d, 0x6f, 0x64, 0x65,
+	0x6c, 0x73, 0x2e, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x52, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x22,
+	0x69, 0x0a, 0x0e, 0x54, 0x72, 0x61, 0x63, 0x6b, 0x4d, 0x75, 0x74, 0x65, 0x53, 0x74, 0x61, 0x74,
+	0x65, 0x12, 0x41, 0x0a, 0x0a, 0x74, 0x72, 0x61, 0x63, 0x6b, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18,
+	0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x22, 0x2e, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x2e, 0x76,
 	0x69, 0x64, 0x65, 0x6f, 0x2e, 0x73, 0x66, 0x75, 0x2e, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x73, 0x2e,
-	0x52, 0x54, 0x4d, 0x50, 0x49, 0x6e, 0x67, 0x72, 0x65, 0x73, 0x73, 0x52, 0x04, 0x72, 0x74, 0x6d,
-	0x70, 0x12, 0x34, 0x0a, 0x14, 0x73, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x72, 0x5f,
-	0x72, 0x74, 0x63, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x73, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x09, 0x42,
-	0x02, 0x18, 0x01, 0x52, 0x12, 0x73, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x72, 0x52,
-	0x74, 0x63, 0x53, 0x74, 0x61, 0x74, 0x73, 0x12, 0x32, 0x0a, 0x13, 0x70, 0x75, 0x62, 0x6c, 0x69,
-	0x73, 0x68, 0x65, 0x72, 0x5f, 0x72, 0x74, 0x63, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x73, 0x18, 0x0e,
-	0x20, 0x01, 0x28, 0x09, 0x42, 0x02, 0x18, 0x01, 0x52, 0x11, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x73,
-	0x68, 0x65, 0x72, 0x52, 0x74, 0x63, 0x53, 0x74, 0x61, 0x74, 0x73, 0x12, 0x1b, 0x0a, 0x09, 0x72,
-	0x74, 0x63, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x73, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08,
-	0x72, 0x74, 0x63, 0x53, 0x74, 0x61, 0x74, 0x73, 0x12, 0x4c, 0x0a, 0x0c, 0x65, 0x6e, 0x63, 0x6f,
-	0x64, 0x65, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x73, 0x18, 0x10, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x29,
-	0x2e, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x2e, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x2e, 0x73, 0x66,
-	0x75, 0x2e, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x73, 0x2e, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x6d,
-	0x61, 0x6e, 0x63, 0x65, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x0b, 0x65, 0x6e, 0x63, 0x6f, 0x64,
-	0x65, 0x53, 0x74, 0x61, 0x74, 0x73, 0x12, 0x4c, 0x0a, 0x0c, 0x64, 0x65, 0x63, 0x6f, 0x64, 0x65,
-	0x5f, 0x73, 0x74, 0x61, 0x74, 0x73, 0x18, 0x11, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x29, 0x2e, 0x73,
+	0x54, 0x72, 0x61, 0x63, 0x6b, 0x54, 0x79, 0x70, 0x65, 0x52, 0x09, 0x74, 0x72, 0x61, 0x63, 0x6b,
+	0x54, 0x79, 0x70, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x6d, 0x75, 0x74, 0x65, 0x64, 0x18, 0x02, 0x20,
+	0x01, 0x28, 0x08, 0x52, 0x05, 0x6d, 0x75, 0x74, 0x65, 0x64, 0x22, 0x28, 0x0a, 0x10, 0x41, 0x75,
+	0x64, 0x69, 0x6f, 0x4d, 0x75, 0x74, 0x65, 0x43, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x64, 0x12, 0x14,
+	0x0a, 0x05, 0x6d, 0x75, 0x74, 0x65, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x05, 0x6d,
+	0x75, 0x74, 0x65, 0x64, 0x22, 0x28, 0x0a, 0x10, 0x56, 0x69, 0x64, 0x65, 0x6f, 0x4d, 0x75, 0x74,
+	0x65, 0x43, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x64, 0x12, 0x14, 0x0a, 0x05, 0x6d, 0x75, 0x74, 0x65,
+	0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x05, 0x6d, 0x75, 0x74, 0x65, 0x64, 0x22, 0x86,
+	0x01, 0x0a, 0x1a, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69,
+	0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1d, 0x0a,
+	0x0a, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x09, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x12, 0x49, 0x0a, 0x06,
+	0x74, 0x72, 0x61, 0x63, 0x6b, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x31, 0x2e, 0x73,
 	0x74, 0x72, 0x65, 0x61, 0x6d, 0x2e, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x2e, 0x73, 0x66, 0x75, 0x2e,
-	0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x73, 0x2e, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x6e,
-	0x63, 0x65, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x0b, 0x64, 0x65, 0x63, 0x6f, 0x64, 0x65, 0x53,
-	0x74, 0x61, 0x74, 0x73, 0x12, 0x2c, 0x0a, 0x12, 0x75, 0x6e, 0x69, 0x66, 0x69, 0x65, 0x64, 0x5f,
-	0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x12, 0x20, 0x01, 0x28, 0x09,
-	0x52, 0x10, 0x75, 0x6e, 0x69, 0x66, 0x69, 0x65, 0x64, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e,
-	0x49, 0x64, 0x42, 0x0e, 0x0a, 0x0c, 0x64, 0x65, 0x76, 0x69, 0x63, 0x65, 0x5f, 0x73, 0x74, 0x61,
-	0x74, 0x65, 0x22, 0x49, 0x0a, 0x11, 0x53, 0x65, 0x6e, 0x64, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52,
-	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x34, 0x0a, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72,
-	0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x2e,
-	0x76, 0x69, 0x64, 0x65, 0x6f, 0x2e, 0x73, 0x66, 0x75, 0x2e, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x73,
-	0x2e, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x52, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x22, 0x72, 0x0a,
-	0x11, 0x49, 0x43, 0x45, 0x52, 0x65, 0x73, 0x74, 0x61, 0x72, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65,
-	0x73, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64,
-	0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x49,
-	0x64, 0x12, 0x3e, 0x0a, 0x09, 0x70, 0x65, 0x65, 0x72, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x02,
+	0x73, 0x69, 0x67, 0x6e, 0x61, 0x6c, 0x2e, 0x54, 0x72, 0x61, 0x63, 0x6b, 0x53, 0x75, 0x62, 0x73,
+	0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52,
+	0x06, 0x74, 0x72, 0x61, 0x63, 0x6b, 0x73, 0x22, 0x53, 0x0a, 0x1b, 0x55, 0x70, 0x64, 0x61, 0x74,
+	0x65, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65,
+	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x34, 0x0a, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x18,
+	0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x2e, 0x76,
+	0x69, 0x64, 0x65, 0x6f, 0x2e, 0x73, 0x66, 0x75, 0x2e, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x73, 0x2e,
+	0x45, 0x72, 0x72, 0x6f, 0x72, 0x52, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x22, 0xdc, 0x01, 0x0a,
+	0x18, 0x54, 0x72, 0x61, 0x63, 0x6b, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69,
+	0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x17, 0x0a, 0x07, 0x75, 0x73, 0x65,
+	0x72, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x75, 0x73, 0x65, 0x72,
+	0x49, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64,
+	0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x49,
+	0x64, 0x12, 0x41, 0x0a, 0x0a, 0x74, 0x72, 0x61, 0x63, 0x6b, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18,
+	0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x22, 0x2e, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x2e, 0x76,
+	0x69, 0x64, 0x65, 0x6f, 0x2e, 0x73, 0x66, 0x75, 0x2e, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x73, 0x2e,
+	0x54, 0x72, 0x61, 0x63, 0x6b, 0x54, 0x79, 0x70, 0x65, 0x52, 0x09, 0x74, 0x72, 0x61, 0x63, 0x6b,
+	0x54, 0x79, 0x70, 0x65, 0x12, 0x45, 0x0a, 0x09, 0x64, 0x69, 0x6d, 0x65, 0x6e, 0x73, 0x69, 0x6f,
+	0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d,
+	0x2e, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x2e, 0x73, 0x66, 0x75, 0x2e, 0x6d, 0x6f, 0x64, 0x65, 0x6c,
+	0x73, 0x2e, 0x56, 0x69, 0x64, 0x65, 0x6f, 0x44, 0x69, 0x6d, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e,
+	0x52, 0x09, 0x64, 0x69, 0x6d, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x22, 0x84, 0x01, 0x0a, 0x11,
+	0x53, 0x65, 0x6e, 0x64, 0x41, 0x6e, 0x73, 0x77, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
+	0x74, 0x12, 0x3e, 0x0a, 0x09, 0x70, 0x65, 0x65, 0x72, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01,
 	0x20, 0x01, 0x28, 0x0e, 0x32, 0x21, 0x2e, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x2e, 0x76, 0x69,
 	0x64, 0x65, 0x6f, 0x2e, 0x73, 0x66, 0x75, 0x2e, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x73, 0x2e, 0x50,
 	0x65, 0x65, 0x72, 0x54, 0x79, 0x70, 0x65, 0x52, 0x08, 0x70, 0x65, 0x65, 0x72, 0x54, 0x79, 0x70,
-	0x65, 0x22, 0x4a, 0x0a, 0x12, 0x49, 0x43, 0x45, 0x52, 0x65, 0x73, 0x74, 0x61, 0x72, 0x74, 0x52,
-	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x34, 0x0a, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72,
-	0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x2e,
-	0x76, 0x69, 0x64, 0x65, 0x6f, 0x2e, 0x73, 0x66, 0x75, 0x2e, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x73,
-	0x2e, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x52, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x22, 0x82, 0x01,
-	0x0a, 0x17, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x4d, 0x75, 0x74, 0x65, 0x53, 0x74, 0x61, 0x74,
-	0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x65, 0x73,
-	0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x73,
-	0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x12, 0x48, 0x0a, 0x0b, 0x6d, 0x75, 0x74, 0x65,
-	0x5f, 0x73, 0x74, 0x61, 0x74, 0x65, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e,
-	0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x2e, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x2e, 0x73, 0x66, 0x75,
-	0x2e, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x6c, 0x2e, 0x54, 0x72, 0x61, 0x63, 0x6b, 0x4d, 0x75, 0x74,
-	0x65, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x0a, 0x6d, 0x75, 0x74, 0x65, 0x53, 0x74, 0x61, 0x74,
-	0x65, 0x73, 0x22, 0x50, 0x0a, 0x18, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x4d, 0x75, 0x74, 0x65,
-	0x53, 0x74, 0x61, 0x74, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x34,
-	0x0a, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e,
-	0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x2e, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x2e, 0x73, 0x66, 0x75,
-	0x2e, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x73, 0x2e, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x52, 0x05, 0x65,
-	0x72, 0x72, 0x6f, 0x72, 0x22, 0x69, 0x0a, 0x0e, 0x54, 0x72, 0x61, 0x63, 0x6b, 0x4d, 0x75, 0x74,
-	0x65, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x41, 0x0a, 0x0a, 0x74, 0x72, 0x61, 0x63, 0x6b, 0x5f,
-	0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x22, 0x2e, 0x73, 0x74, 0x72,
-	0x65, 0x61, 0x6d, 0x2e, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x2e, 0x73, 0x66, 0x75, 0x2e, 0x6d, 0x6f,
-	0x64, 0x65, 0x6c, 0x73, 0x2e, 0x54, 0x72, 0x61, 0x63, 0x6b, 0x54, 0x79, 0x70, 0x65, 0x52, 0x09,
-	0x74, 0x72, 0x61, 0x63, 0x6b, 0x54, 0x79, 0x70, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x6d, 0x75, 0x74,
-	0x65, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x05, 0x6d, 0x75, 0x74, 0x65, 0x64, 0x22,
-	0x28, 0x0a, 0x10, 0x41, 0x75, 0x64, 0x69, 0x6f, 0x4d, 0x75, 0x74, 0x65, 0x43, 0x68, 0x61, 0x6e,
-	0x67, 0x65, 0x64, 0x12, 0x14, 0x0a, 0x05, 0x6d, 0x75, 0x74, 0x65, 0x64, 0x18, 0x01, 0x20, 0x01,
-	0x28, 0x08, 0x52, 0x05, 0x6d, 0x75, 0x74, 0x65, 0x64, 0x22, 0x28, 0x0a, 0x10, 0x56, 0x69, 0x64,
-	0x65, 0x6f, 0x4d, 0x75, 0x74, 0x65, 0x43, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x64, 0x12, 0x14, 0x0a,
-	0x05, 0x6d, 0x75, 0x74, 0x65, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x05, 0x6d, 0x75,
-	0x74, 0x65, 0x64, 0x22, 0x86, 0x01, 0x0a, 0x1a, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x53, 0x75,
-	0x62, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65,
-	0x73, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64,
-	0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x49,
-	0x64, 0x12, 0x49, 0x0a, 0x06, 0x74, 0x72, 0x61, 0x63, 0x6b, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28,
-	0x0b, 0x32, 0x31, 0x2e, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x2e, 0x76, 0x69, 0x64, 0x65, 0x6f,
-	0x2e, 0x73, 0x66, 0x75, 0x2e, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x6c, 0x2e, 0x54, 0x72, 0x61, 0x63,
-	0x6b, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74,
-	0x61, 0x69, 0x6c, 0x73, 0x52, 0x06, 0x74, 0x72, 0x61, 0x63, 0x6b, 0x73, 0x22, 0x53, 0x0a, 0x1b,
-	0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69,
-	0x6f, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x34, 0x0a, 0x05, 0x65,
-	0x72, 0x72, 0x6f, 0x72, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x73, 0x74, 0x72,
-	0x65, 0x61, 0x6d, 0x2e, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x2e, 0x73, 0x66, 0x75, 0x2e, 0x6d, 0x6f,
-	0x64, 0x65, 0x6c, 0x73, 0x2e, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x52, 0x05, 0x65, 0x72, 0x72, 0x6f,
-	0x72, 0x22, 0xdc, 0x01, 0x0a, 0x18, 0x54, 0x72, 0x61, 0x63, 0x6b, 0x53, 0x75, 0x62, 0x73, 0x63,
-	0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x17,
-	0x0a, 0x07, 0x75, 0x73, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52,
-	0x06, 0x75, 0x73, 0x65, 0x72, 0x49, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x65, 0x73, 0x73, 0x69,
-	0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x73, 0x65, 0x73,
-	0x73, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x12, 0x41, 0x0a, 0x0a, 0x74, 0x72, 0x61, 0x63, 0x6b, 0x5f,
-	0x74, 0x79, 0x70, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x22, 0x2e, 0x73, 0x74, 0x72,
-	0x65, 0x61, 0x6d, 0x2e, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x2e, 0x73, 0x66, 0x75, 0x2e, 0x6d, 0x6f,
-	0x64, 0x65, 0x6c, 0x73, 0x2e, 0x54, 0x72, 0x61, 0x63, 0x6b, 0x54, 0x79, 0x70, 0x65, 0x52, 0x09,
-	0x74, 0x72, 0x61, 0x63, 0x6b, 0x54, 0x79, 0x70, 0x65, 0x12, 0x45, 0x0a, 0x09, 0x64, 0x69, 0x6d,
-	0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x73,
-	0x74, 0x72, 0x65, 0x61, 0x6d, 0x2e, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x2e, 0x73, 0x66, 0x75, 0x2e,
-	0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x73, 0x2e, 0x56, 0x69, 0x64, 0x65, 0x6f, 0x44, 0x69, 0x6d, 0x65,
-	0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x09, 0x64, 0x69, 0x6d, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e,
-	0x22, 0x84, 0x01, 0x0a, 0x11, 0x53, 0x65, 0x6e, 0x64, 0x41, 0x6e, 0x73, 0x77, 0x65, 0x72, 0x52,
-	0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x3e, 0x0a, 0x09, 0x70, 0x65, 0x65, 0x72, 0x5f, 0x74,
-	0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x21, 0x2e, 0x73, 0x74, 0x72, 0x65,
+	0x65, 0x12, 0x10, 0x0a, 0x03, 0x73, 0x64, 0x70, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03,
+	0x73, 0x64, 0x70, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x69,
+	0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e,
+	0x49, 0x64, 0x22, 0x4a, 0x0a, 0x12, 0x53, 0x65, 0x6e, 0x64, 0x41, 0x6e, 0x73, 0x77, 0x65, 0x72,
+	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x34, 0x0a, 0x05, 0x65, 0x72, 0x72, 0x6f,
+	0x72, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d,
+	0x2e, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x2e, 0x73, 0x66, 0x75, 0x2e, 0x6d, 0x6f, 0x64, 0x65, 0x6c,
+	0x73, 0x2e, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x52, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x22, 0x4a,
+	0x0a, 0x12, 0x49, 0x43, 0x45, 0x54, 0x72, 0x69, 0x63, 0x6b, 0x6c, 0x65, 0x52, 0x65, 0x73, 0x70,
+	0x6f, 0x6e, 0x73, 0x65, 0x12, 0x34, 0x0a, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x18, 0x04, 0x20,
+	0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x2e, 0x76, 0x69, 0x64,
+	0x65, 0x6f, 0x2e, 0x73, 0x66, 0x75, 0x2e, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x73, 0x2e, 0x45, 0x72,
+	0x72, 0x6f, 0x72, 0x52, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x22, 0x82, 0x01, 0x0a, 0x13, 0x53,
+	0x65, 0x74, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65,
+	0x73, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x73, 0x64, 0x70, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x03, 0x73, 0x64, 0x70, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x5f,
+	0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f,
+	0x6e, 0x49, 0x64, 0x12, 0x3a, 0x0a, 0x06, 0x74, 0x72, 0x61, 0x63, 0x6b, 0x73, 0x18, 0x03, 0x20,
+	0x03, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x2e, 0x76, 0x69, 0x64,
+	0x65, 0x6f, 0x2e, 0x73, 0x66, 0x75, 0x2e, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x73, 0x2e, 0x54, 0x72,
+	0x61, 0x63, 0x6b, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x06, 0x74, 0x72, 0x61, 0x63, 0x6b, 0x73, 0x22,
+	0x9e, 0x01, 0x0a, 0x14, 0x53, 0x65, 0x74, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x65, 0x72,
+	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x10, 0x0a, 0x03, 0x73, 0x64, 0x70, 0x18,
+	0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x73, 0x64, 0x70, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x65,
+	0x73, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09,
+	0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x69, 0x63, 0x65,
+	0x5f, 0x72, 0x65, 0x73, 0x74, 0x61, 0x72, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a,
+	0x69, 0x63, 0x65, 0x52, 0x65, 0x73, 0x74, 0x61, 0x72, 0x74, 0x12, 0x34, 0x0a, 0x05, 0x65, 0x72,
+	0x72, 0x6f, 0x72, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x73, 0x74, 0x72, 0x65,
 	0x61, 0x6d, 0x2e, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x2e, 0x73, 0x66, 0x75, 0x2e, 0x6d, 0x6f, 0x64,
-	0x65, 0x6c, 0x73, 0x2e, 0x50, 0x65, 0x65, 0x72, 0x54, 0x79, 0x70, 0x65, 0x52, 0x08, 0x70, 0x65,
-	0x65, 0x72, 0x54, 0x79, 0x70, 0x65, 0x12, 0x10, 0x0a, 0x03, 0x73, 0x64, 0x70, 0x18, 0x02, 0x20,
-	0x01, 0x28, 0x09, 0x52, 0x03, 0x73, 0x64, 0x70, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x65, 0x73, 0x73,
-	0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x73, 0x65,
-	0x73, 0x73, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x22, 0x4a, 0x0a, 0x12, 0x53, 0x65, 0x6e, 0x64, 0x41,
-	0x6e, 0x73, 0x77, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x34, 0x0a,
-	0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x73,
+	0x65, 0x6c, 0x73, 0x2e, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x52, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72,
+	0x32, 0x88, 0x09, 0x0a, 0x0c, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x6c, 0x53, 0x65, 0x72, 0x76, 0x65,
+	0x72, 0x12, 0x6b, 0x0a, 0x0c, 0x53, 0x65, 0x74, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x65,
+	0x72, 0x12, 0x2c, 0x2e, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x2e, 0x76, 0x69, 0x64, 0x65, 0x6f,
+	0x2e, 0x73, 0x66, 0x75, 0x2e, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x6c, 0x2e, 0x53, 0x65, 0x74, 0x50,
+	0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a,
+	0x2d, 0x2e, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x2e, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x2e, 0x73,
+	0x66, 0x75, 0x2e, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x6c, 0x2e, 0x53, 0x65, 0x74, 0x50, 0x75, 0x62,
+	0x6c, 0x69, 0x73, 0x68, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x65,
+	0x0a, 0x0a, 0x53, 0x65, 0x6e, 0x64, 0x41, 0x6e, 0x73, 0x77, 0x65, 0x72, 0x12, 0x2a, 0x2e, 0x73,
 	0x74, 0x72, 0x65, 0x61, 0x6d, 0x2e, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x2e, 0x73, 0x66, 0x75, 0x2e,
-	0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x73, 0x2e, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x52, 0x05, 0x65, 0x72,
-	0x72, 0x6f, 0x72, 0x22, 0x4a, 0x0a, 0x12, 0x49, 0x43, 0x45, 0x54, 0x72, 0x69, 0x63, 0x6b, 0x6c,
-	0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x34, 0x0a, 0x05, 0x65, 0x72, 0x72,
-	0x6f, 0x72, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x73, 0x74, 0x72, 0x65, 0x61,
-	0x6d, 0x2e, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x2e, 0x73, 0x66, 0x75, 0x2e, 0x6d, 0x6f, 0x64, 0x65,
-	0x6c, 0x73, 0x2e, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x52, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x22,
-	0x82, 0x01, 0x0a, 0x13, 0x53, 0x65, 0x74, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x65, 0x72,
-	0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x73, 0x64, 0x70, 0x18, 0x01,
-	0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x73, 0x64, 0x70, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x65, 0x73,
-	0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x73,
-	0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x12, 0x3a, 0x0a, 0x06, 0x74, 0x72, 0x61, 0x63,
-	0x6b, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x73, 0x74, 0x72, 0x65, 0x61,
-	0x6d, 0x2e, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x2e, 0x73, 0x66, 0x75, 0x2e, 0x6d, 0x6f, 0x64, 0x65,
-	0x6c, 0x73, 0x2e, 0x54, 0x72, 0x61, 0x63, 0x6b, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x06, 0x74, 0x72,
-	0x61, 0x63, 0x6b, 0x73, 0x22, 0x9e, 0x01, 0x0a, 0x14, 0x53, 0x65, 0x74, 0x50, 0x75, 0x62, 0x6c,
-	0x69, 0x73, 0x68, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x10, 0x0a,
-	0x03, 0x73, 0x64, 0x70, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x73, 0x64, 0x70, 0x12,
-	0x1d, 0x0a, 0x0a, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20,
-	0x01, 0x28, 0x09, 0x52, 0x09, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x12, 0x1f,
-	0x0a, 0x0b, 0x69, 0x63, 0x65, 0x5f, 0x72, 0x65, 0x73, 0x74, 0x61, 0x72, 0x74, 0x18, 0x03, 0x20,
-	0x01, 0x28, 0x08, 0x52, 0x0a, 0x69, 0x63, 0x65, 0x52, 0x65, 0x73, 0x74, 0x61, 0x72, 0x74, 0x12,
-	0x34, 0x0a, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e,
-	0x2e, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x2e, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x2e, 0x73, 0x66,
-	0x75, 0x2e, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x73, 0x2e, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x52, 0x05,
-	0x65, 0x72, 0x72, 0x6f, 0x72, 0x32, 0x9e, 0x08, 0x0a, 0x0c, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x6c,
-	0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x12, 0x6b, 0x0a, 0x0c, 0x53, 0x65, 0x74, 0x50, 0x75, 0x62,
-	0x6c, 0x69, 0x73, 0x68, 0x65, 0x72, 0x12, 0x2c, 0x2e, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x2e,
-	0x76, 0x69, 0x64, 0x65, 0x6f, 0x2e, 0x73, 0x66, 0x75, 0x2e, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x6c,
-	0x2e, 0x53, 0x65, 0x74, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x65, 0x72, 0x52, 0x65, 0x71,
-	0x75, 0x65, 0x73, 0x74, 0x1a, 0x2d, 0x2e, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x2e, 0x76, 0x69,
-	0x64, 0x65, 0x6f, 0x2e, 0x73, 0x66, 0x75, 0x2e, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x6c, 0x2e, 0x53,
-	0x65, 0x74, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f,
-	0x6e, 0x73, 0x65, 0x12, 0x65, 0x0a, 0x0a, 0x53, 0x65, 0x6e, 0x64, 0x41, 0x6e, 0x73, 0x77, 0x65,
-	0x72, 0x12, 0x2a, 0x2e, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x2e, 0x76, 0x69, 0x64, 0x65, 0x6f,
-	0x2e, 0x73, 0x66, 0x75, 0x2e, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x6c, 0x2e, 0x53, 0x65, 0x6e, 0x64,
-	0x41, 0x6e, 0x73, 0x77, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2b, 0x2e,
-	0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x2e, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x2e, 0x73, 0x66, 0x75,
-	0x2e, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x6c, 0x2e, 0x53, 0x65, 0x6e, 0x64, 0x41, 0x6e, 0x73, 0x77,
-	0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x5e, 0x0a, 0x0a, 0x49, 0x63,
-	0x65, 0x54, 0x72, 0x69, 0x63, 0x6b, 0x6c, 0x65, 0x12, 0x23, 0x2e, 0x73, 0x74, 0x72, 0x65, 0x61,
-	0x6d, 0x2e, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x2e, 0x73, 0x66, 0x75, 0x2e, 0x6d, 0x6f, 0x64, 0x65,
-	0x6c, 0x73, 0x2e, 0x49, 0x43, 0x45, 0x54, 0x72, 0x69, 0x63, 0x6b, 0x6c, 0x65, 0x1a, 0x2b, 0x2e,
+	0x73, 0x69, 0x67, 0x6e, 0x61, 0x6c, 0x2e, 0x53, 0x65, 0x6e, 0x64, 0x41, 0x6e, 0x73, 0x77, 0x65,
+	0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2b, 0x2e, 0x73, 0x74, 0x72, 0x65, 0x61,
+	0x6d, 0x2e, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x2e, 0x73, 0x66, 0x75, 0x2e, 0x73, 0x69, 0x67, 0x6e,
+	0x61, 0x6c, 0x2e, 0x53, 0x65, 0x6e, 0x64, 0x41, 0x6e, 0x73, 0x77, 0x65, 0x72, 0x52, 0x65, 0x73,
+	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x5e, 0x0a, 0x0a, 0x49, 0x63, 0x65, 0x54, 0x72, 0x69, 0x63,
+	0x6b, 0x6c, 0x65, 0x12, 0x23, 0x2e, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x2e, 0x76, 0x69, 0x64,
+	0x65, 0x6f, 0x2e, 0x73, 0x66, 0x75, 0x2e, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x73, 0x2e, 0x49, 0x43,
+	0x45, 0x54, 0x72, 0x69, 0x63, 0x6b, 0x6c, 0x65, 0x1a, 0x2b, 0x2e, 0x73, 0x74, 0x72, 0x65, 0x61,
+	0x6d, 0x2e, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x2e, 0x73, 0x66, 0x75, 0x2e, 0x73, 0x69, 0x67, 0x6e,
+	0x61, 0x6c, 0x2e, 0x49, 0x43, 0x45, 0x54, 0x72, 0x69, 0x63, 0x6b, 0x6c, 0x65, 0x52, 0x65, 0x73,
+	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x80, 0x01, 0x0a, 0x13, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65,
+	0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x33, 0x2e,
 	0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x2e, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x2e, 0x73, 0x66, 0x75,
-	0x2e, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x6c, 0x2e, 0x49, 0x43, 0x45, 0x54, 0x72, 0x69, 0x63, 0x6b,
-	0x6c, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x80, 0x01, 0x0a, 0x13, 0x55,
-	0x70, 0x64, 0x61, 0x74, 0x65, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f,
-	0x6e, 0x73, 0x12, 0x33, 0x2e, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x2e, 0x76, 0x69, 0x64, 0x65,
+	0x2e, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x6c, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x53, 0x75,
+	0x62, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65,
+	0x73, 0x74, 0x1a, 0x34, 0x2e, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x2e, 0x76, 0x69, 0x64, 0x65,
 	0x6f, 0x2e, 0x73, 0x66, 0x75, 0x2e, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x6c, 0x2e, 0x55, 0x70, 0x64,
 	0x61, 0x74, 0x65, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73,
-	0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x34, 0x2e, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d,
-	0x2e, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x2e, 0x73, 0x66, 0x75, 0x2e, 0x73, 0x69, 0x67, 0x6e, 0x61,
-	0x6c, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x70,
-	0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x77, 0x0a,
-	0x10, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x4d, 0x75, 0x74, 0x65, 0x53, 0x74, 0x61, 0x74, 0x65,
-	0x73, 0x12, 0x30, 0x2e, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x2e, 0x76, 0x69, 0x64, 0x65, 0x6f,
-	0x2e, 0x73, 0x66, 0x75, 0x2e, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x6c, 0x2e, 0x55, 0x70, 0x64, 0x61,
-	0x74, 0x65, 0x4d, 0x75, 0x74, 0x65, 0x53, 0x74, 0x61, 0x74, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75,
-	0x65, 0x73, 0x74, 0x1a, 0x31, 0x2e, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x2e, 0x76, 0x69, 0x64,
-	0x65, 0x6f, 0x2e, 0x73, 0x66, 0x75, 0x2e, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x6c, 0x2e, 0x55, 0x70,
-	0x64, 0x61, 0x74, 0x65, 0x4d, 0x75, 0x74, 0x65, 0x53, 0x74, 0x61, 0x74, 0x65, 0x73, 0x52, 0x65,
-	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x65, 0x0a, 0x0a, 0x49, 0x63, 0x65, 0x52, 0x65, 0x73,
-	0x74, 0x61, 0x72, 0x74, 0x12, 0x2a, 0x2e, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x2e, 0x76, 0x69,
-	0x64, 0x65, 0x6f, 0x2e, 0x73, 0x66, 0x75, 0x2e, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x6c, 0x2e, 0x49,
-	0x43, 0x45, 0x52, 0x65, 0x73, 0x74, 0x61, 0x72, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
-	0x1a, 0x2b, 0x2e, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x2e, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x2e,
-	0x73, 0x66, 0x75, 0x2e, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x6c, 0x2e, 0x49, 0x43, 0x45, 0x52, 0x65,
-	0x73, 0x74, 0x61, 0x72, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x62, 0x0a,
-	0x09, 0x53, 0x65, 0x6e, 0x64, 0x53, 0x74, 0x61, 0x74, 0x73, 0x12, 0x29, 0x2e, 0x73, 0x74, 0x72,
-	0x65, 0x61, 0x6d, 0x2e, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x2e, 0x73, 0x66, 0x75, 0x2e, 0x73, 0x69,
-	0x67, 0x6e, 0x61, 0x6c, 0x2e, 0x53, 0x65, 0x6e, 0x64, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x65,
-	0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2a, 0x2e, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x2e, 0x76,
-	0x69, 0x64, 0x65, 0x6f, 0x2e, 0x73, 0x66, 0x75, 0x2e, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x6c, 0x2e,
-	0x53, 0x65, 0x6e, 0x64, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
-	0x65, 0x12, 0x89, 0x01, 0x0a, 0x16, 0x53, 0x74, 0x61, 0x72, 0x74, 0x4e, 0x6f, 0x69, 0x73, 0x65,
-	0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x36, 0x2e, 0x73,
+	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x77, 0x0a, 0x10, 0x55, 0x70, 0x64, 0x61,
+	0x74, 0x65, 0x4d, 0x75, 0x74, 0x65, 0x53, 0x74, 0x61, 0x74, 0x65, 0x73, 0x12, 0x30, 0x2e, 0x73,
 	0x74, 0x72, 0x65, 0x61, 0x6d, 0x2e, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x2e, 0x73, 0x66, 0x75, 0x2e,
-	0x73, 0x69, 0x67, 0x6e, 0x61, 0x6c, 0x2e, 0x53, 0x74, 0x61, 0x72, 0x74, 0x4e, 0x6f, 0x69, 0x73,
-	0x65, 0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71,
-	0x75, 0x65, 0x73, 0x74, 0x1a, 0x37, 0x2e, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x2e, 0x76, 0x69,
-	0x64, 0x65, 0x6f, 0x2e, 0x73, 0x66, 0x75, 0x2e, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x6c, 0x2e, 0x53,
-	0x74, 0x61, 0x72, 0x74, 0x4e, 0x6f, 0x69, 0x73, 0x65, 0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x6c,
-	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x86, 0x01,
-	0x0a, 0x15, 0x53, 0x74, 0x6f, 0x70, 0x4e, 0x6f, 0x69, 0x73, 0x65, 0x43, 0x61, 0x6e, 0x63, 0x65,
-	0x6c, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x35, 0x2e, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d,
-	0x2e, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x2e, 0x73, 0x66, 0x75, 0x2e, 0x73, 0x69, 0x67, 0x6e, 0x61,
-	0x6c, 0x2e, 0x53, 0x74, 0x6f, 0x70, 0x4e, 0x6f, 0x69, 0x73, 0x65, 0x43, 0x61, 0x6e, 0x63, 0x65,
-	0x6c, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x36,
+	0x73, 0x69, 0x67, 0x6e, 0x61, 0x6c, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x4d, 0x75, 0x74,
+	0x65, 0x53, 0x74, 0x61, 0x74, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x31,
 	0x2e, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x2e, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x2e, 0x73, 0x66,
-	0x75, 0x2e, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x6c, 0x2e, 0x53, 0x74, 0x6f, 0x70, 0x4e, 0x6f, 0x69,
-	0x73, 0x65, 0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65,
-	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x42, 0x69, 0x42, 0x0b, 0x53, 0x66, 0x75, 0x53, 0x69, 0x67,
-	0x6e, 0x61, 0x6c, 0x56, 0x31, 0x50, 0x01, 0x5a, 0x3b, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e,
-	0x63, 0x6f, 0x6d, 0x2f, 0x47, 0x65, 0x74, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x2f, 0x70, 0x72,
-	0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f,
-	0x76, 0x69, 0x64, 0x65, 0x6f, 0x2f, 0x73, 0x66, 0x75, 0x2f, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x6c,
-	0x5f, 0x72, 0x70, 0x63, 0xaa, 0x02, 0x1a, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x2e, 0x56, 0x69,
-	0x64, 0x65, 0x6f, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x66, 0x75, 0x2e, 0x53, 0x69, 0x67, 0x6e, 0x61,
-	0x6c, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+	0x75, 0x2e, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x6c, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x4d,
+	0x75, 0x74, 0x65, 0x53, 0x74, 0x61, 0x74, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
+	0x65, 0x12, 0x65, 0x0a, 0x0a, 0x49, 0x63, 0x65, 0x52, 0x65, 0x73, 0x74, 0x61, 0x72, 0x74, 0x12,
+	0x2a, 0x2e, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x2e, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x2e, 0x73,
+	0x66, 0x75, 0x2e, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x6c, 0x2e, 0x49, 0x43, 0x45, 0x52, 0x65, 0x73,
+	0x74, 0x61, 0x72, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2b, 0x2e, 0x73, 0x74,
+	0x72, 0x65, 0x61, 0x6d, 0x2e, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x2e, 0x73, 0x66, 0x75, 0x2e, 0x73,
+	0x69, 0x67, 0x6e, 0x61, 0x6c, 0x2e, 0x49, 0x43, 0x45, 0x52, 0x65, 0x73, 0x74, 0x61, 0x72, 0x74,
+	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x62, 0x0a, 0x09, 0x53, 0x65, 0x6e, 0x64,
+	0x53, 0x74, 0x61, 0x74, 0x73, 0x12, 0x29, 0x2e, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x2e, 0x76,
+	0x69, 0x64, 0x65, 0x6f, 0x2e, 0x73, 0x66, 0x75, 0x2e, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x6c, 0x2e,
+	0x53, 0x65, 0x6e, 0x64, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
+	0x1a, 0x2a, 0x2e, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x2e, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x2e,
+	0x73, 0x66, 0x75, 0x2e, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x6c, 0x2e, 0x53, 0x65, 0x6e, 0x64, 0x53,
+	0x74, 0x61, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x68, 0x0a, 0x0b,
+	0x53, 0x65, 0x6e, 0x64, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x12, 0x2b, 0x2e, 0x73, 0x74,
+	0x72, 0x65, 0x61, 0x6d, 0x2e, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x2e, 0x73, 0x66, 0x75, 0x2e, 0x73,
+	0x69, 0x67, 0x6e, 0x61, 0x6c, 0x2e, 0x53, 0x65, 0x6e, 0x64, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63,
+	0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2c, 0x2e, 0x73, 0x74, 0x72, 0x65, 0x61,
+	0x6d, 0x2e, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x2e, 0x73, 0x66, 0x75, 0x2e, 0x73, 0x69, 0x67, 0x6e,
+	0x61, 0x6c, 0x2e, 0x53, 0x65, 0x6e, 0x64, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x52, 0x65,
+	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x89, 0x01, 0x0a, 0x16, 0x53, 0x74, 0x61, 0x72, 0x74,
+	0x4e, 0x6f, 0x69, 0x73, 0x65, 0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x6c, 0x61, 0x74, 0x69, 0x6f,
+	0x6e, 0x12, 0x36, 0x2e, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x2e, 0x76, 0x69, 0x64, 0x65, 0x6f,
+	0x2e, 0x73, 0x66, 0x75, 0x2e, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x6c, 0x2e, 0x53, 0x74, 0x61, 0x72,
+	0x74, 0x4e, 0x6f, 0x69, 0x73, 0x65, 0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x6c, 0x61, 0x74, 0x69,
+	0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x37, 0x2e, 0x73, 0x74, 0x72, 0x65,
+	0x61, 0x6d, 0x2e, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x2e, 0x73, 0x66, 0x75, 0x2e, 0x73, 0x69, 0x67,
+	0x6e, 0x61, 0x6c, 0x2e, 0x53, 0x74, 0x61, 0x72, 0x74, 0x4e, 0x6f, 0x69, 0x73, 0x65, 0x43, 0x61,
+	0x6e, 0x63, 0x65, 0x6c, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
+	0x73, 0x65, 0x12, 0x86, 0x01, 0x0a, 0x15, 0x53, 0x74, 0x6f, 0x70, 0x4e, 0x6f, 0x69, 0x73, 0x65,
+	0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x35, 0x2e, 0x73,
+	0x74, 0x72, 0x65, 0x61, 0x6d, 0x2e, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x2e, 0x73, 0x66, 0x75, 0x2e,
+	0x73, 0x69, 0x67, 0x6e, 0x61, 0x6c, 0x2e, 0x53, 0x74, 0x6f, 0x70, 0x4e, 0x6f, 0x69, 0x73, 0x65,
+	0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75,
+	0x65, 0x73, 0x74, 0x1a, 0x36, 0x2e, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x2e, 0x76, 0x69, 0x64,
+	0x65, 0x6f, 0x2e, 0x73, 0x66, 0x75, 0x2e, 0x73, 0x69, 0x67, 0x6e, 0x61, 0x6c, 0x2e, 0x53, 0x74,
+	0x6f, 0x70, 0x4e, 0x6f, 0x69, 0x73, 0x65, 0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x6c, 0x61, 0x74,
+	0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x42, 0x69, 0x42, 0x0b, 0x53,
+	0x66, 0x75, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x6c, 0x56, 0x31, 0x50, 0x01, 0x5a, 0x3b, 0x67, 0x69,
+	0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x47, 0x65, 0x74, 0x53, 0x74, 0x72, 0x65,
+	0x61, 0x6d, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x2f, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x62, 0x75, 0x66, 0x2f, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x2f, 0x73, 0x66, 0x75, 0x2f, 0x73,
+	0x69, 0x67, 0x6e, 0x61, 0x6c, 0x5f, 0x72, 0x70, 0x63, 0xaa, 0x02, 0x1a, 0x53, 0x74, 0x72, 0x65,
+	0x61, 0x6d, 0x2e, 0x56, 0x69, 0x64, 0x65, 0x6f, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x66, 0x75, 0x2e,
+	0x53, 0x69, 0x67, 0x6e, 0x61, 0x6c, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
 }
 
 var (
@@ -1730,7 +1888,7 @@ func file_video_sfu_signal_rpc_signal_proto_rawDescGZIP() []byte {
 	return file_video_sfu_signal_rpc_signal_proto_rawDescData
 }
 
-var file_video_sfu_signal_rpc_signal_proto_msgTypes = make([]protoimpl.MessageInfo, 23)
+var file_video_sfu_signal_rpc_signal_proto_msgTypes = make([]protoimpl.MessageInfo, 25)
 var file_video_sfu_signal_rpc_signal_proto_goTypes = []interface{}{
 	(*StartNoiseCancellationRequest)(nil),  // 0: stream.video.sfu.signal.StartNoiseCancellationRequest
 	(*StartNoiseCancellationResponse)(nil), // 1: stream.video.sfu.signal.StartNoiseCancellationResponse
@@ -1738,87 +1896,99 @@ var file_video_sfu_signal_rpc_signal_proto_goTypes = []interface{}{
 	(*StopNoiseCancellationResponse)(nil),  // 3: stream.video.sfu.signal.StopNoiseCancellationResponse
 	(*Reconnection)(nil),                   // 4: stream.video.sfu.signal.Reconnection
 	(*Telemetry)(nil),                      // 5: stream.video.sfu.signal.Telemetry
-	(*SendStatsRequest)(nil),               // 6: stream.video.sfu.signal.SendStatsRequest
-	(*SendStatsResponse)(nil),              // 7: stream.video.sfu.signal.SendStatsResponse
-	(*ICERestartRequest)(nil),              // 8: stream.video.sfu.signal.ICERestartRequest
-	(*ICERestartResponse)(nil),             // 9: stream.video.sfu.signal.ICERestartResponse
-	(*UpdateMuteStatesRequest)(nil),        // 10: stream.video.sfu.signal.UpdateMuteStatesRequest
-	(*UpdateMuteStatesResponse)(nil),       // 11: stream.video.sfu.signal.UpdateMuteStatesResponse
-	(*TrackMuteState)(nil),                 // 12: stream.video.sfu.signal.TrackMuteState
-	(*AudioMuteChanged)(nil),               // 13: stream.video.sfu.signal.AudioMuteChanged
-	(*VideoMuteChanged)(nil),               // 14: stream.video.sfu.signal.VideoMuteChanged
-	(*UpdateSubscriptionsRequest)(nil),     // 15: stream.video.sfu.signal.UpdateSubscriptionsRequest
-	(*UpdateSubscriptionsResponse)(nil),    // 16: stream.video.sfu.signal.UpdateSubscriptionsResponse
-	(*TrackSubscriptionDetails)(nil),       // 17: stream.video.sfu.signal.TrackSubscriptionDetails
-	(*SendAnswerRequest)(nil),              // 18: stream.video.sfu.signal.SendAnswerRequest
-	(*SendAnswerResponse)(nil),             // 19: stream.video.sfu.signal.SendAnswerResponse
-	(*ICETrickleResponse)(nil),             // 20: stream.video.sfu.signal.ICETrickleResponse
-	(*SetPublisherRequest)(nil),            // 21: stream.video.sfu.signal.SetPublisherRequest
-	(*SetPublisherResponse)(nil),           // 22: stream.video.sfu.signal.SetPublisherResponse
-	(*models.Error)(nil),                   // 23: stream.video.sfu.models.Error
-	(models.WebsocketReconnectStrategy)(0), // 24: stream.video.sfu.models.WebsocketReconnectStrategy
-	(*models.InputDevices)(nil),            // 25: stream.video.sfu.models.InputDevices
-	(*models.AndroidState)(nil),            // 26: stream.video.sfu.models.AndroidState
-	(*models.AppleState)(nil),              // 27: stream.video.sfu.models.AppleState
-	(*models.RTMPIngress)(nil),             // 28: stream.video.sfu.models.RTMPIngress
-	(*models.PerformanceStats)(nil),        // 29: stream.video.sfu.models.PerformanceStats
-	(models.PeerType)(0),                   // 30: stream.video.sfu.models.PeerType
-	(models.TrackType)(0),                  // 31: stream.video.sfu.models.TrackType
-	(*models.VideoDimension)(nil),          // 32: stream.video.sfu.models.VideoDimension
-	(*models.TrackInfo)(nil),               // 33: stream.video.sfu.models.TrackInfo
-	(*models.ICETrickle)(nil),              // 34: stream.video.sfu.models.ICETrickle
+	(*SendMetricsRequest)(nil),             // 6: stream.video.sfu.signal.SendMetricsRequest
+	(*SendMetricsResponse)(nil),            // 7: stream.video.sfu.signal.SendMetricsResponse
+	(*SendStatsRequest)(nil),               // 8: stream.video.sfu.signal.SendStatsRequest
+	(*SendStatsResponse)(nil),              // 9: stream.video.sfu.signal.SendStatsResponse
+	(*ICERestartRequest)(nil),              // 10: stream.video.sfu.signal.ICERestartRequest
+	(*ICERestartResponse)(nil),             // 11: stream.video.sfu.signal.ICERestartResponse
+	(*UpdateMuteStatesRequest)(nil),        // 12: stream.video.sfu.signal.UpdateMuteStatesRequest
+	(*UpdateMuteStatesResponse)(nil),       // 13: stream.video.sfu.signal.UpdateMuteStatesResponse
+	(*TrackMuteState)(nil),                 // 14: stream.video.sfu.signal.TrackMuteState
+	(*AudioMuteChanged)(nil),               // 15: stream.video.sfu.signal.AudioMuteChanged
+	(*VideoMuteChanged)(nil),               // 16: stream.video.sfu.signal.VideoMuteChanged
+	(*UpdateSubscriptionsRequest)(nil),     // 17: stream.video.sfu.signal.UpdateSubscriptionsRequest
+	(*UpdateSubscriptionsResponse)(nil),    // 18: stream.video.sfu.signal.UpdateSubscriptionsResponse
+	(*TrackSubscriptionDetails)(nil),       // 19: stream.video.sfu.signal.TrackSubscriptionDetails
+	(*SendAnswerRequest)(nil),              // 20: stream.video.sfu.signal.SendAnswerRequest
+	(*SendAnswerResponse)(nil),             // 21: stream.video.sfu.signal.SendAnswerResponse
+	(*ICETrickleResponse)(nil),             // 22: stream.video.sfu.signal.ICETrickleResponse
+	(*SetPublisherRequest)(nil),            // 23: stream.video.sfu.signal.SetPublisherRequest
+	(*SetPublisherResponse)(nil),           // 24: stream.video.sfu.signal.SetPublisherResponse
+	(*models.Error)(nil),                   // 25: stream.video.sfu.models.Error
+	(models.WebsocketReconnectStrategy)(0), // 26: stream.video.sfu.models.WebsocketReconnectStrategy
+	(*models.InboundRtp)(nil),              // 27: stream.video.sfu.models.InboundRtp
+	(*models.OutboundRtp)(nil),             // 28: stream.video.sfu.models.OutboundRtp
+	(*models.RemoteInboundRtp)(nil),        // 29: stream.video.sfu.models.RemoteInboundRtp
+	(*models.RemoteOutboundRtp)(nil),       // 30: stream.video.sfu.models.RemoteOutboundRtp
+	(*models.InputDevices)(nil),            // 31: stream.video.sfu.models.InputDevices
+	(*models.AndroidState)(nil),            // 32: stream.video.sfu.models.AndroidState
+	(*models.AppleState)(nil),              // 33: stream.video.sfu.models.AppleState
+	(*models.RTMPIngress)(nil),             // 34: stream.video.sfu.models.RTMPIngress
+	(*models.PerformanceStats)(nil),        // 35: stream.video.sfu.models.PerformanceStats
+	(models.PeerType)(0),                   // 36: stream.video.sfu.models.PeerType
+	(models.TrackType)(0),                  // 37: stream.video.sfu.models.TrackType
+	(*models.VideoDimension)(nil),          // 38: stream.video.sfu.models.VideoDimension
+	(*models.TrackInfo)(nil),               // 39: stream.video.sfu.models.TrackInfo
+	(*models.ICETrickle)(nil),              // 40: stream.video.sfu.models.ICETrickle
 }
 var file_video_sfu_signal_rpc_signal_proto_depIdxs = []int32{
-	23, // 0: stream.video.sfu.signal.StartNoiseCancellationResponse.error:type_name -> stream.video.sfu.models.Error
-	23, // 1: stream.video.sfu.signal.StopNoiseCancellationResponse.error:type_name -> stream.video.sfu.models.Error
-	24, // 2: stream.video.sfu.signal.Reconnection.strategy:type_name -> stream.video.sfu.models.WebsocketReconnectStrategy
+	25, // 0: stream.video.sfu.signal.StartNoiseCancellationResponse.error:type_name -> stream.video.sfu.models.Error
+	25, // 1: stream.video.sfu.signal.StopNoiseCancellationResponse.error:type_name -> stream.video.sfu.models.Error
+	26, // 2: stream.video.sfu.signal.Reconnection.strategy:type_name -> stream.video.sfu.models.WebsocketReconnectStrategy
 	4,  // 3: stream.video.sfu.signal.Telemetry.reconnection:type_name -> stream.video.sfu.signal.Reconnection
-	25, // 4: stream.video.sfu.signal.SendStatsRequest.audio_devices:type_name -> stream.video.sfu.models.InputDevices
-	25, // 5: stream.video.sfu.signal.SendStatsRequest.video_devices:type_name -> stream.video.sfu.models.InputDevices
-	26, // 6: stream.video.sfu.signal.SendStatsRequest.android:type_name -> stream.video.sfu.models.AndroidState
-	27, // 7: stream.video.sfu.signal.SendStatsRequest.apple:type_name -> stream.video.sfu.models.AppleState
-	5,  // 8: stream.video.sfu.signal.SendStatsRequest.telemetry:type_name -> stream.video.sfu.signal.Telemetry
-	28, // 9: stream.video.sfu.signal.SendStatsRequest.rtmp:type_name -> stream.video.sfu.models.RTMPIngress
-	29, // 10: stream.video.sfu.signal.SendStatsRequest.encode_stats:type_name -> stream.video.sfu.models.PerformanceStats
-	29, // 11: stream.video.sfu.signal.SendStatsRequest.decode_stats:type_name -> stream.video.sfu.models.PerformanceStats
-	23, // 12: stream.video.sfu.signal.SendStatsResponse.error:type_name -> stream.video.sfu.models.Error
-	30, // 13: stream.video.sfu.signal.ICERestartRequest.peer_type:type_name -> stream.video.sfu.models.PeerType
-	23, // 14: stream.video.sfu.signal.ICERestartResponse.error:type_name -> stream.video.sfu.models.Error
-	12, // 15: stream.video.sfu.signal.UpdateMuteStatesRequest.mute_states:type_name -> stream.video.sfu.signal.TrackMuteState
-	23, // 16: stream.video.sfu.signal.UpdateMuteStatesResponse.error:type_name -> stream.video.sfu.models.Error
-	31, // 17: stream.video.sfu.signal.TrackMuteState.track_type:type_name -> stream.video.sfu.models.TrackType
-	17, // 18: stream.video.sfu.signal.UpdateSubscriptionsRequest.tracks:type_name -> stream.video.sfu.signal.TrackSubscriptionDetails
-	23, // 19: stream.video.sfu.signal.UpdateSubscriptionsResponse.error:type_name -> stream.video.sfu.models.Error
-	31, // 20: stream.video.sfu.signal.TrackSubscriptionDetails.track_type:type_name -> stream.video.sfu.models.TrackType
-	32, // 21: stream.video.sfu.signal.TrackSubscriptionDetails.dimension:type_name -> stream.video.sfu.models.VideoDimension
-	30, // 22: stream.video.sfu.signal.SendAnswerRequest.peer_type:type_name -> stream.video.sfu.models.PeerType
-	23, // 23: stream.video.sfu.signal.SendAnswerResponse.error:type_name -> stream.video.sfu.models.Error
-	23, // 24: stream.video.sfu.signal.ICETrickleResponse.error:type_name -> stream.video.sfu.models.Error
-	33, // 25: stream.video.sfu.signal.SetPublisherRequest.tracks:type_name -> stream.video.sfu.models.TrackInfo
-	23, // 26: stream.video.sfu.signal.SetPublisherResponse.error:type_name -> stream.video.sfu.models.Error
-	21, // 27: stream.video.sfu.signal.SignalServer.SetPublisher:input_type -> stream.video.sfu.signal.SetPublisherRequest
-	18, // 28: stream.video.sfu.signal.SignalServer.SendAnswer:input_type -> stream.video.sfu.signal.SendAnswerRequest
-	34, // 29: stream.video.sfu.signal.SignalServer.IceTrickle:input_type -> stream.video.sfu.models.ICETrickle
-	15, // 30: stream.video.sfu.signal.SignalServer.UpdateSubscriptions:input_type -> stream.video.sfu.signal.UpdateSubscriptionsRequest
-	10, // 31: stream.video.sfu.signal.SignalServer.UpdateMuteStates:input_type -> stream.video.sfu.signal.UpdateMuteStatesRequest
-	8,  // 32: stream.video.sfu.signal.SignalServer.IceRestart:input_type -> stream.video.sfu.signal.ICERestartRequest
-	6,  // 33: stream.video.sfu.signal.SignalServer.SendStats:input_type -> stream.video.sfu.signal.SendStatsRequest
-	0,  // 34: stream.video.sfu.signal.SignalServer.StartNoiseCancellation:input_type -> stream.video.sfu.signal.StartNoiseCancellationRequest
-	2,  // 35: stream.video.sfu.signal.SignalServer.StopNoiseCancellation:input_type -> stream.video.sfu.signal.StopNoiseCancellationRequest
-	22, // 36: stream.video.sfu.signal.SignalServer.SetPublisher:output_type -> stream.video.sfu.signal.SetPublisherResponse
-	19, // 37: stream.video.sfu.signal.SignalServer.SendAnswer:output_type -> stream.video.sfu.signal.SendAnswerResponse
-	20, // 38: stream.video.sfu.signal.SignalServer.IceTrickle:output_type -> stream.video.sfu.signal.ICETrickleResponse
-	16, // 39: stream.video.sfu.signal.SignalServer.UpdateSubscriptions:output_type -> stream.video.sfu.signal.UpdateSubscriptionsResponse
-	11, // 40: stream.video.sfu.signal.SignalServer.UpdateMuteStates:output_type -> stream.video.sfu.signal.UpdateMuteStatesResponse
-	9,  // 41: stream.video.sfu.signal.SignalServer.IceRestart:output_type -> stream.video.sfu.signal.ICERestartResponse
-	7,  // 42: stream.video.sfu.signal.SignalServer.SendStats:output_type -> stream.video.sfu.signal.SendStatsResponse
-	1,  // 43: stream.video.sfu.signal.SignalServer.StartNoiseCancellation:output_type -> stream.video.sfu.signal.StartNoiseCancellationResponse
-	3,  // 44: stream.video.sfu.signal.SignalServer.StopNoiseCancellation:output_type -> stream.video.sfu.signal.StopNoiseCancellationResponse
-	36, // [36:45] is the sub-list for method output_type
-	27, // [27:36] is the sub-list for method input_type
-	27, // [27:27] is the sub-list for extension type_name
-	27, // [27:27] is the sub-list for extension extendee
-	0,  // [0:27] is the sub-list for field type_name
+	27, // 4: stream.video.sfu.signal.SendMetricsRequest.inbounds:type_name -> stream.video.sfu.models.InboundRtp
+	28, // 5: stream.video.sfu.signal.SendMetricsRequest.outbounds:type_name -> stream.video.sfu.models.OutboundRtp
+	29, // 6: stream.video.sfu.signal.SendMetricsRequest.remote_inbounds:type_name -> stream.video.sfu.models.RemoteInboundRtp
+	30, // 7: stream.video.sfu.signal.SendMetricsRequest.remote_outbounds:type_name -> stream.video.sfu.models.RemoteOutboundRtp
+	31, // 8: stream.video.sfu.signal.SendStatsRequest.audio_devices:type_name -> stream.video.sfu.models.InputDevices
+	31, // 9: stream.video.sfu.signal.SendStatsRequest.video_devices:type_name -> stream.video.sfu.models.InputDevices
+	32, // 10: stream.video.sfu.signal.SendStatsRequest.android:type_name -> stream.video.sfu.models.AndroidState
+	33, // 11: stream.video.sfu.signal.SendStatsRequest.apple:type_name -> stream.video.sfu.models.AppleState
+	5,  // 12: stream.video.sfu.signal.SendStatsRequest.telemetry:type_name -> stream.video.sfu.signal.Telemetry
+	34, // 13: stream.video.sfu.signal.SendStatsRequest.rtmp:type_name -> stream.video.sfu.models.RTMPIngress
+	35, // 14: stream.video.sfu.signal.SendStatsRequest.encode_stats:type_name -> stream.video.sfu.models.PerformanceStats
+	35, // 15: stream.video.sfu.signal.SendStatsRequest.decode_stats:type_name -> stream.video.sfu.models.PerformanceStats
+	25, // 16: stream.video.sfu.signal.SendStatsResponse.error:type_name -> stream.video.sfu.models.Error
+	36, // 17: stream.video.sfu.signal.ICERestartRequest.peer_type:type_name -> stream.video.sfu.models.PeerType
+	25, // 18: stream.video.sfu.signal.ICERestartResponse.error:type_name -> stream.video.sfu.models.Error
+	14, // 19: stream.video.sfu.signal.UpdateMuteStatesRequest.mute_states:type_name -> stream.video.sfu.signal.TrackMuteState
+	25, // 20: stream.video.sfu.signal.UpdateMuteStatesResponse.error:type_name -> stream.video.sfu.models.Error
+	37, // 21: stream.video.sfu.signal.TrackMuteState.track_type:type_name -> stream.video.sfu.models.TrackType
+	19, // 22: stream.video.sfu.signal.UpdateSubscriptionsRequest.tracks:type_name -> stream.video.sfu.signal.TrackSubscriptionDetails
+	25, // 23: stream.video.sfu.signal.UpdateSubscriptionsResponse.error:type_name -> stream.video.sfu.models.Error
+	37, // 24: stream.video.sfu.signal.TrackSubscriptionDetails.track_type:type_name -> stream.video.sfu.models.TrackType
+	38, // 25: stream.video.sfu.signal.TrackSubscriptionDetails.dimension:type_name -> stream.video.sfu.models.VideoDimension
+	36, // 26: stream.video.sfu.signal.SendAnswerRequest.peer_type:type_name -> stream.video.sfu.models.PeerType
+	25, // 27: stream.video.sfu.signal.SendAnswerResponse.error:type_name -> stream.video.sfu.models.Error
+	25, // 28: stream.video.sfu.signal.ICETrickleResponse.error:type_name -> stream.video.sfu.models.Error
+	39, // 29: stream.video.sfu.signal.SetPublisherRequest.tracks:type_name -> stream.video.sfu.models.TrackInfo
+	25, // 30: stream.video.sfu.signal.SetPublisherResponse.error:type_name -> stream.video.sfu.models.Error
+	23, // 31: stream.video.sfu.signal.SignalServer.SetPublisher:input_type -> stream.video.sfu.signal.SetPublisherRequest
+	20, // 32: stream.video.sfu.signal.SignalServer.SendAnswer:input_type -> stream.video.sfu.signal.SendAnswerRequest
+	40, // 33: stream.video.sfu.signal.SignalServer.IceTrickle:input_type -> stream.video.sfu.models.ICETrickle
+	17, // 34: stream.video.sfu.signal.SignalServer.UpdateSubscriptions:input_type -> stream.video.sfu.signal.UpdateSubscriptionsRequest
+	12, // 35: stream.video.sfu.signal.SignalServer.UpdateMuteStates:input_type -> stream.video.sfu.signal.UpdateMuteStatesRequest
+	10, // 36: stream.video.sfu.signal.SignalServer.IceRestart:input_type -> stream.video.sfu.signal.ICERestartRequest
+	8,  // 37: stream.video.sfu.signal.SignalServer.SendStats:input_type -> stream.video.sfu.signal.SendStatsRequest
+	6,  // 38: stream.video.sfu.signal.SignalServer.SendMetrics:input_type -> stream.video.sfu.signal.SendMetricsRequest
+	0,  // 39: stream.video.sfu.signal.SignalServer.StartNoiseCancellation:input_type -> stream.video.sfu.signal.StartNoiseCancellationRequest
+	2,  // 40: stream.video.sfu.signal.SignalServer.StopNoiseCancellation:input_type -> stream.video.sfu.signal.StopNoiseCancellationRequest
+	24, // 41: stream.video.sfu.signal.SignalServer.SetPublisher:output_type -> stream.video.sfu.signal.SetPublisherResponse
+	21, // 42: stream.video.sfu.signal.SignalServer.SendAnswer:output_type -> stream.video.sfu.signal.SendAnswerResponse
+	22, // 43: stream.video.sfu.signal.SignalServer.IceTrickle:output_type -> stream.video.sfu.signal.ICETrickleResponse
+	18, // 44: stream.video.sfu.signal.SignalServer.UpdateSubscriptions:output_type -> stream.video.sfu.signal.UpdateSubscriptionsResponse
+	13, // 45: stream.video.sfu.signal.SignalServer.UpdateMuteStates:output_type -> stream.video.sfu.signal.UpdateMuteStatesResponse
+	11, // 46: stream.video.sfu.signal.SignalServer.IceRestart:output_type -> stream.video.sfu.signal.ICERestartResponse
+	9,  // 47: stream.video.sfu.signal.SignalServer.SendStats:output_type -> stream.video.sfu.signal.SendStatsResponse
+	7,  // 48: stream.video.sfu.signal.SignalServer.SendMetrics:output_type -> stream.video.sfu.signal.SendMetricsResponse
+	1,  // 49: stream.video.sfu.signal.SignalServer.StartNoiseCancellation:output_type -> stream.video.sfu.signal.StartNoiseCancellationResponse
+	3,  // 50: stream.video.sfu.signal.SignalServer.StopNoiseCancellation:output_type -> stream.video.sfu.signal.StopNoiseCancellationResponse
+	41, // [41:51] is the sub-list for method output_type
+	31, // [31:41] is the sub-list for method input_type
+	31, // [31:31] is the sub-list for extension type_name
+	31, // [31:31] is the sub-list for extension extendee
+	0,  // [0:31] is the sub-list for field type_name
 }
 
 func init() { file_video_sfu_signal_rpc_signal_proto_init() }
@@ -1900,7 +2070,7 @@ func file_video_sfu_signal_rpc_signal_proto_init() {
 			}
 		}
 		file_video_sfu_signal_rpc_signal_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*SendStatsRequest); i {
+			switch v := v.(*SendMetricsRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -1912,7 +2082,7 @@ func file_video_sfu_signal_rpc_signal_proto_init() {
 			}
 		}
 		file_video_sfu_signal_rpc_signal_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*SendStatsResponse); i {
+			switch v := v.(*SendMetricsResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -1924,7 +2094,7 @@ func file_video_sfu_signal_rpc_signal_proto_init() {
 			}
 		}
 		file_video_sfu_signal_rpc_signal_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*ICERestartRequest); i {
+			switch v := v.(*SendStatsRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -1936,7 +2106,7 @@ func file_video_sfu_signal_rpc_signal_proto_init() {
 			}
 		}
 		file_video_sfu_signal_rpc_signal_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*ICERestartResponse); i {
+			switch v := v.(*SendStatsResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -1948,7 +2118,7 @@ func file_video_sfu_signal_rpc_signal_proto_init() {
 			}
 		}
 		file_video_sfu_signal_rpc_signal_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*UpdateMuteStatesRequest); i {
+			switch v := v.(*ICERestartRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -1960,7 +2130,7 @@ func file_video_sfu_signal_rpc_signal_proto_init() {
 			}
 		}
 		file_video_sfu_signal_rpc_signal_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*UpdateMuteStatesResponse); i {
+			switch v := v.(*ICERestartResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -1972,7 +2142,7 @@ func file_video_sfu_signal_rpc_signal_proto_init() {
 			}
 		}
 		file_video_sfu_signal_rpc_signal_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*TrackMuteState); i {
+			switch v := v.(*UpdateMuteStatesRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -1984,7 +2154,7 @@ func file_video_sfu_signal_rpc_signal_proto_init() {
 			}
 		}
 		file_video_sfu_signal_rpc_signal_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*AudioMuteChanged); i {
+			switch v := v.(*UpdateMuteStatesResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -1996,7 +2166,7 @@ func file_video_sfu_signal_rpc_signal_proto_init() {
 			}
 		}
 		file_video_sfu_signal_rpc_signal_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*VideoMuteChanged); i {
+			switch v := v.(*TrackMuteState); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -2008,7 +2178,7 @@ func file_video_sfu_signal_rpc_signal_proto_init() {
 			}
 		}
 		file_video_sfu_signal_rpc_signal_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*UpdateSubscriptionsRequest); i {
+			switch v := v.(*AudioMuteChanged); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -2020,7 +2190,7 @@ func file_video_sfu_signal_rpc_signal_proto_init() {
 			}
 		}
 		file_video_sfu_signal_rpc_signal_proto_msgTypes[16].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*UpdateSubscriptionsResponse); i {
+			switch v := v.(*VideoMuteChanged); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -2032,7 +2202,7 @@ func file_video_sfu_signal_rpc_signal_proto_init() {
 			}
 		}
 		file_video_sfu_signal_rpc_signal_proto_msgTypes[17].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*TrackSubscriptionDetails); i {
+			switch v := v.(*UpdateSubscriptionsRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -2044,7 +2214,7 @@ func file_video_sfu_signal_rpc_signal_proto_init() {
 			}
 		}
 		file_video_sfu_signal_rpc_signal_proto_msgTypes[18].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*SendAnswerRequest); i {
+			switch v := v.(*UpdateSubscriptionsResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -2056,7 +2226,7 @@ func file_video_sfu_signal_rpc_signal_proto_init() {
 			}
 		}
 		file_video_sfu_signal_rpc_signal_proto_msgTypes[19].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*SendAnswerResponse); i {
+			switch v := v.(*TrackSubscriptionDetails); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -2068,7 +2238,7 @@ func file_video_sfu_signal_rpc_signal_proto_init() {
 			}
 		}
 		file_video_sfu_signal_rpc_signal_proto_msgTypes[20].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*ICETrickleResponse); i {
+			switch v := v.(*SendAnswerRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -2080,7 +2250,7 @@ func file_video_sfu_signal_rpc_signal_proto_init() {
 			}
 		}
 		file_video_sfu_signal_rpc_signal_proto_msgTypes[21].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*SetPublisherRequest); i {
+			switch v := v.(*SendAnswerResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -2092,6 +2262,30 @@ func file_video_sfu_signal_rpc_signal_proto_init() {
 			}
 		}
 		file_video_sfu_signal_rpc_signal_proto_msgTypes[22].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*ICETrickleResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_video_sfu_signal_rpc_signal_proto_msgTypes[23].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*SetPublisherRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_video_sfu_signal_rpc_signal_proto_msgTypes[24].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*SetPublisherResponse); i {
 			case 0:
 				return &v.state
@@ -2108,7 +2302,7 @@ func file_video_sfu_signal_rpc_signal_proto_init() {
 		(*Telemetry_ConnectionTimeSeconds)(nil),
 		(*Telemetry_Reconnection)(nil),
 	}
-	file_video_sfu_signal_rpc_signal_proto_msgTypes[6].OneofWrappers = []interface{}{
+	file_video_sfu_signal_rpc_signal_proto_msgTypes[8].OneofWrappers = []interface{}{
 		(*SendStatsRequest_Android)(nil),
 		(*SendStatsRequest_Apple)(nil),
 	}
@@ -2118,7 +2312,7 @@ func file_video_sfu_signal_rpc_signal_proto_init() {
 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
 			RawDescriptor: file_video_sfu_signal_rpc_signal_proto_rawDesc,
 			NumEnums:      0,
-			NumMessages:   23,
+			NumMessages:   25,
 			NumExtensions: 0,
 			NumServices:   1,
 		},
diff --git a/protobuf/video/sfu/signal_rpc/signal.proto b/protobuf/video/sfu/signal_rpc/signal.proto
index c87b62fd7..292b79d6d 100644
--- a/protobuf/video/sfu/signal_rpc/signal.proto
+++ b/protobuf/video/sfu/signal_rpc/signal.proto
@@ -30,6 +30,8 @@ service SignalServer {
 
   rpc SendStats(SendStatsRequest) returns (SendStatsResponse);
 
+  rpc SendMetrics(SendMetricsRequest) returns (SendMetricsResponse);
+
   rpc StartNoiseCancellation(StartNoiseCancellationRequest) returns (StartNoiseCancellationResponse);
 
   rpc StopNoiseCancellation(StopNoiseCancellationRequest) returns (StopNoiseCancellationResponse);
@@ -63,6 +65,20 @@ message Telemetry {
   }
 }
 
+message SendMetricsRequest {
+  string session_id = 1;
+  string unified_session_id = 2;
+
+  repeated models.InboundRtp inbounds = 3;
+  repeated models.OutboundRtp outbounds = 4;
+  repeated models.RemoteInboundRtp remote_inbounds = 5;
+  repeated models.RemoteOutboundRtp remote_outbounds = 6;
+}
+
+message SendMetricsResponse {
+
+}
+
 message SendStatsRequest {
   string session_id = 1;
   string subscriber_stats = 2;
diff --git a/protobuf/video/sfu/signal_rpc/signal.twirp.go b/protobuf/video/sfu/signal_rpc/signal.twirp.go
index aa03cd00e..6105e8fbe 100644
--- a/protobuf/video/sfu/signal_rpc/signal.twirp.go
+++ b/protobuf/video/sfu/signal_rpc/signal.twirp.go
@@ -54,6 +54,8 @@ type SignalServer interface {
 
 	SendStats(context.Context, *SendStatsRequest) (*SendStatsResponse, error)
 
+	SendMetrics(context.Context, *SendMetricsRequest) (*SendMetricsResponse, error)
+
 	StartNoiseCancellation(context.Context, *StartNoiseCancellationRequest) (*StartNoiseCancellationResponse, error)
 
 	StopNoiseCancellation(context.Context, *StopNoiseCancellationRequest) (*StopNoiseCancellationResponse, error)
@@ -65,7 +67,7 @@ type SignalServer interface {
 
 type signalServerProtobufClient struct {
 	client      HTTPClient
-	urls        [9]string
+	urls        [10]string
 	interceptor twirp.Interceptor
 	opts        twirp.ClientOptions
 }
@@ -93,7 +95,7 @@ func NewSignalServerProtobufClient(baseURL string, client HTTPClient, opts ...tw
 	// Build method URLs: <baseURL>[<prefix>]/<package>.<Service>/<Method>
 	serviceURL := sanitizeBaseURL(baseURL)
 	serviceURL += baseServicePath(pathPrefix, "stream.video.sfu.signal", "SignalServer")
-	urls := [9]string{
+	urls := [10]string{
 		serviceURL + "SetPublisher",
 		serviceURL + "SendAnswer",
 		serviceURL + "IceTrickle",
@@ -101,6 +103,7 @@ func NewSignalServerProtobufClient(baseURL string, client HTTPClient, opts ...tw
 		serviceURL + "UpdateMuteStates",
 		serviceURL + "IceRestart",
 		serviceURL + "SendStats",
+		serviceURL + "SendMetrics",
 		serviceURL + "StartNoiseCancellation",
 		serviceURL + "StopNoiseCancellation",
 	}
@@ -435,6 +438,52 @@ func (c *signalServerProtobufClient) callSendStats(ctx context.Context, in *Send
 	return out, nil
 }
 
+func (c *signalServerProtobufClient) SendMetrics(ctx context.Context, in *SendMetricsRequest) (*SendMetricsResponse, error) {
+	ctx = ctxsetters.WithPackageName(ctx, "stream.video.sfu.signal")
+	ctx = ctxsetters.WithServiceName(ctx, "SignalServer")
+	ctx = ctxsetters.WithMethodName(ctx, "SendMetrics")
+	caller := c.callSendMetrics
+	if c.interceptor != nil {
+		caller = func(ctx context.Context, req *SendMetricsRequest) (*SendMetricsResponse, error) {
+			resp, err := c.interceptor(
+				func(ctx context.Context, req interface{}) (interface{}, error) {
+					typedReq, ok := req.(*SendMetricsRequest)
+					if !ok {
+						return nil, twirp.InternalError("failed type assertion req.(*SendMetricsRequest) when calling interceptor")
+					}
+					return c.callSendMetrics(ctx, typedReq)
+				},
+			)(ctx, req)
+			if resp != nil {
+				typedResp, ok := resp.(*SendMetricsResponse)
+				if !ok {
+					return nil, twirp.InternalError("failed type assertion resp.(*SendMetricsResponse) when calling interceptor")
+				}
+				return typedResp, err
+			}
+			return nil, err
+		}
+	}
+	return caller(ctx, in)
+}
+
+func (c *signalServerProtobufClient) callSendMetrics(ctx context.Context, in *SendMetricsRequest) (*SendMetricsResponse, error) {
+	out := new(SendMetricsResponse)
+	ctx, err := doProtobufRequest(ctx, c.client, c.opts.Hooks, c.urls[7], in, out)
+	if err != nil {
+		twerr, ok := err.(twirp.Error)
+		if !ok {
+			twerr = twirp.InternalErrorWith(err)
+		}
+		callClientError(ctx, c.opts.Hooks, twerr)
+		return nil, err
+	}
+
+	callClientResponseReceived(ctx, c.opts.Hooks)
+
+	return out, nil
+}
+
 func (c *signalServerProtobufClient) StartNoiseCancellation(ctx context.Context, in *StartNoiseCancellationRequest) (*StartNoiseCancellationResponse, error) {
 	ctx = ctxsetters.WithPackageName(ctx, "stream.video.sfu.signal")
 	ctx = ctxsetters.WithServiceName(ctx, "SignalServer")
@@ -466,7 +515,7 @@ func (c *signalServerProtobufClient) StartNoiseCancellation(ctx context.Context,
 
 func (c *signalServerProtobufClient) callStartNoiseCancellation(ctx context.Context, in *StartNoiseCancellationRequest) (*StartNoiseCancellationResponse, error) {
 	out := new(StartNoiseCancellationResponse)
-	ctx, err := doProtobufRequest(ctx, c.client, c.opts.Hooks, c.urls[7], in, out)
+	ctx, err := doProtobufRequest(ctx, c.client, c.opts.Hooks, c.urls[8], in, out)
 	if err != nil {
 		twerr, ok := err.(twirp.Error)
 		if !ok {
@@ -512,7 +561,7 @@ func (c *signalServerProtobufClient) StopNoiseCancellation(ctx context.Context,
 
 func (c *signalServerProtobufClient) callStopNoiseCancellation(ctx context.Context, in *StopNoiseCancellationRequest) (*StopNoiseCancellationResponse, error) {
 	out := new(StopNoiseCancellationResponse)
-	ctx, err := doProtobufRequest(ctx, c.client, c.opts.Hooks, c.urls[8], in, out)
+	ctx, err := doProtobufRequest(ctx, c.client, c.opts.Hooks, c.urls[9], in, out)
 	if err != nil {
 		twerr, ok := err.(twirp.Error)
 		if !ok {
@@ -533,7 +582,7 @@ func (c *signalServerProtobufClient) callStopNoiseCancellation(ctx context.Conte
 
 type signalServerJSONClient struct {
 	client      HTTPClient
-	urls        [9]string
+	urls        [10]string
 	interceptor twirp.Interceptor
 	opts        twirp.ClientOptions
 }
@@ -561,7 +610,7 @@ func NewSignalServerJSONClient(baseURL string, client HTTPClient, opts ...twirp.
 	// Build method URLs: <baseURL>[<prefix>]/<package>.<Service>/<Method>
 	serviceURL := sanitizeBaseURL(baseURL)
 	serviceURL += baseServicePath(pathPrefix, "stream.video.sfu.signal", "SignalServer")
-	urls := [9]string{
+	urls := [10]string{
 		serviceURL + "SetPublisher",
 		serviceURL + "SendAnswer",
 		serviceURL + "IceTrickle",
@@ -569,6 +618,7 @@ func NewSignalServerJSONClient(baseURL string, client HTTPClient, opts ...twirp.
 		serviceURL + "UpdateMuteStates",
 		serviceURL + "IceRestart",
 		serviceURL + "SendStats",
+		serviceURL + "SendMetrics",
 		serviceURL + "StartNoiseCancellation",
 		serviceURL + "StopNoiseCancellation",
 	}
@@ -903,6 +953,52 @@ func (c *signalServerJSONClient) callSendStats(ctx context.Context, in *SendStat
 	return out, nil
 }
 
+func (c *signalServerJSONClient) SendMetrics(ctx context.Context, in *SendMetricsRequest) (*SendMetricsResponse, error) {
+	ctx = ctxsetters.WithPackageName(ctx, "stream.video.sfu.signal")
+	ctx = ctxsetters.WithServiceName(ctx, "SignalServer")
+	ctx = ctxsetters.WithMethodName(ctx, "SendMetrics")
+	caller := c.callSendMetrics
+	if c.interceptor != nil {
+		caller = func(ctx context.Context, req *SendMetricsRequest) (*SendMetricsResponse, error) {
+			resp, err := c.interceptor(
+				func(ctx context.Context, req interface{}) (interface{}, error) {
+					typedReq, ok := req.(*SendMetricsRequest)
+					if !ok {
+						return nil, twirp.InternalError("failed type assertion req.(*SendMetricsRequest) when calling interceptor")
+					}
+					return c.callSendMetrics(ctx, typedReq)
+				},
+			)(ctx, req)
+			if resp != nil {
+				typedResp, ok := resp.(*SendMetricsResponse)
+				if !ok {
+					return nil, twirp.InternalError("failed type assertion resp.(*SendMetricsResponse) when calling interceptor")
+				}
+				return typedResp, err
+			}
+			return nil, err
+		}
+	}
+	return caller(ctx, in)
+}
+
+func (c *signalServerJSONClient) callSendMetrics(ctx context.Context, in *SendMetricsRequest) (*SendMetricsResponse, error) {
+	out := new(SendMetricsResponse)
+	ctx, err := doJSONRequest(ctx, c.client, c.opts.Hooks, c.urls[7], in, out)
+	if err != nil {
+		twerr, ok := err.(twirp.Error)
+		if !ok {
+			twerr = twirp.InternalErrorWith(err)
+		}
+		callClientError(ctx, c.opts.Hooks, twerr)
+		return nil, err
+	}
+
+	callClientResponseReceived(ctx, c.opts.Hooks)
+
+	return out, nil
+}
+
 func (c *signalServerJSONClient) StartNoiseCancellation(ctx context.Context, in *StartNoiseCancellationRequest) (*StartNoiseCancellationResponse, error) {
 	ctx = ctxsetters.WithPackageName(ctx, "stream.video.sfu.signal")
 	ctx = ctxsetters.WithServiceName(ctx, "SignalServer")
@@ -934,7 +1030,7 @@ func (c *signalServerJSONClient) StartNoiseCancellation(ctx context.Context, in
 
 func (c *signalServerJSONClient) callStartNoiseCancellation(ctx context.Context, in *StartNoiseCancellationRequest) (*StartNoiseCancellationResponse, error) {
 	out := new(StartNoiseCancellationResponse)
-	ctx, err := doJSONRequest(ctx, c.client, c.opts.Hooks, c.urls[7], in, out)
+	ctx, err := doJSONRequest(ctx, c.client, c.opts.Hooks, c.urls[8], in, out)
 	if err != nil {
 		twerr, ok := err.(twirp.Error)
 		if !ok {
@@ -980,7 +1076,7 @@ func (c *signalServerJSONClient) StopNoiseCancellation(ctx context.Context, in *
 
 func (c *signalServerJSONClient) callStopNoiseCancellation(ctx context.Context, in *StopNoiseCancellationRequest) (*StopNoiseCancellationResponse, error) {
 	out := new(StopNoiseCancellationResponse)
-	ctx, err := doJSONRequest(ctx, c.client, c.opts.Hooks, c.urls[8], in, out)
+	ctx, err := doJSONRequest(ctx, c.client, c.opts.Hooks, c.urls[9], in, out)
 	if err != nil {
 		twerr, ok := err.(twirp.Error)
 		if !ok {
@@ -1113,6 +1209,9 @@ func (s *signalServerServer) ServeHTTP(resp http.ResponseWriter, req *http.Reque
 	case "SendStats":
 		s.serveSendStats(ctx, resp, req)
 		return
+	case "SendMetrics":
+		s.serveSendMetrics(ctx, resp, req)
+		return
 	case "StartNoiseCancellation":
 		s.serveStartNoiseCancellation(ctx, resp, req)
 		return
@@ -2386,6 +2485,186 @@ func (s *signalServerServer) serveSendStatsProtobuf(ctx context.Context, resp ht
 	callResponseSent(ctx, s.hooks)
 }
 
+func (s *signalServerServer) serveSendMetrics(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
+	header := req.Header.Get("Content-Type")
+	i := strings.Index(header, ";")
+	if i == -1 {
+		i = len(header)
+	}
+	switch strings.TrimSpace(strings.ToLower(header[:i])) {
+	case "application/json":
+		s.serveSendMetricsJSON(ctx, resp, req)
+	case "application/protobuf":
+		s.serveSendMetricsProtobuf(ctx, resp, req)
+	default:
+		msg := fmt.Sprintf("unexpected Content-Type: %q", req.Header.Get("Content-Type"))
+		twerr := badRouteError(msg, req.Method, req.URL.Path)
+		s.writeError(ctx, resp, twerr)
+	}
+}
+
+func (s *signalServerServer) serveSendMetricsJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
+	var err error
+	ctx = ctxsetters.WithMethodName(ctx, "SendMetrics")
+	ctx, err = callRequestRouted(ctx, s.hooks)
+	if err != nil {
+		s.writeError(ctx, resp, err)
+		return
+	}
+
+	d := json.NewDecoder(req.Body)
+	rawReqBody := json.RawMessage{}
+	if err := d.Decode(&rawReqBody); err != nil {
+		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
+		return
+	}
+	reqContent := new(SendMetricsRequest)
+	unmarshaler := protojson.UnmarshalOptions{DiscardUnknown: true}
+	if err = unmarshaler.Unmarshal(rawReqBody, reqContent); err != nil {
+		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
+		return
+	}
+
+	handler := s.SignalServer.SendMetrics
+	if s.interceptor != nil {
+		handler = func(ctx context.Context, req *SendMetricsRequest) (*SendMetricsResponse, error) {
+			resp, err := s.interceptor(
+				func(ctx context.Context, req interface{}) (interface{}, error) {
+					typedReq, ok := req.(*SendMetricsRequest)
+					if !ok {
+						return nil, twirp.InternalError("failed type assertion req.(*SendMetricsRequest) when calling interceptor")
+					}
+					return s.SignalServer.SendMetrics(ctx, typedReq)
+				},
+			)(ctx, req)
+			if resp != nil {
+				typedResp, ok := resp.(*SendMetricsResponse)
+				if !ok {
+					return nil, twirp.InternalError("failed type assertion resp.(*SendMetricsResponse) when calling interceptor")
+				}
+				return typedResp, err
+			}
+			return nil, err
+		}
+	}
+
+	// Call service method
+	var respContent *SendMetricsResponse
+	func() {
+		defer ensurePanicResponses(ctx, resp, s.hooks)
+		respContent, err = handler(ctx, reqContent)
+	}()
+
+	if err != nil {
+		s.writeError(ctx, resp, err)
+		return
+	}
+	if respContent == nil {
+		s.writeError(ctx, resp, twirp.InternalError("received a nil *SendMetricsResponse and nil error while calling SendMetrics. nil responses are not supported"))
+		return
+	}
+
+	ctx = callResponsePrepared(ctx, s.hooks)
+
+	marshaler := &protojson.MarshalOptions{UseProtoNames: !s.jsonCamelCase, EmitUnpopulated: !s.jsonSkipDefaults}
+	respBytes, err := marshaler.Marshal(respContent)
+	if err != nil {
+		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal json response"))
+		return
+	}
+
+	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
+	resp.Header().Set("Content-Type", "application/json")
+	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
+	resp.WriteHeader(http.StatusOK)
+
+	if n, err := resp.Write(respBytes); err != nil {
+		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
+		twerr := twirp.NewError(twirp.Unknown, msg)
+		ctx = callError(ctx, s.hooks, twerr)
+	}
+	callResponseSent(ctx, s.hooks)
+}
+
+func (s *signalServerServer) serveSendMetricsProtobuf(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
+	var err error
+	ctx = ctxsetters.WithMethodName(ctx, "SendMetrics")
+	ctx, err = callRequestRouted(ctx, s.hooks)
+	if err != nil {
+		s.writeError(ctx, resp, err)
+		return
+	}
+
+	buf, err := ioutil.ReadAll(req.Body)
+	if err != nil {
+		s.handleRequestBodyError(ctx, resp, "failed to read request body", err)
+		return
+	}
+	reqContent := new(SendMetricsRequest)
+	if err = reqContent.UnmarshalVT(buf); err != nil {
+		s.writeError(ctx, resp, malformedRequestError("the protobuf request could not be decoded"))
+		return
+	}
+
+	handler := s.SignalServer.SendMetrics
+	if s.interceptor != nil {
+		handler = func(ctx context.Context, req *SendMetricsRequest) (*SendMetricsResponse, error) {
+			resp, err := s.interceptor(
+				func(ctx context.Context, req interface{}) (interface{}, error) {
+					typedReq, ok := req.(*SendMetricsRequest)
+					if !ok {
+						return nil, twirp.InternalError("failed type assertion req.(*SendMetricsRequest) when calling interceptor")
+					}
+					return s.SignalServer.SendMetrics(ctx, typedReq)
+				},
+			)(ctx, req)
+			if resp != nil {
+				typedResp, ok := resp.(*SendMetricsResponse)
+				if !ok {
+					return nil, twirp.InternalError("failed type assertion resp.(*SendMetricsResponse) when calling interceptor")
+				}
+				return typedResp, err
+			}
+			return nil, err
+		}
+	}
+
+	// Call service method
+	var respContent *SendMetricsResponse
+	func() {
+		defer ensurePanicResponses(ctx, resp, s.hooks)
+		respContent, err = handler(ctx, reqContent)
+	}()
+
+	if err != nil {
+		s.writeError(ctx, resp, err)
+		return
+	}
+	if respContent == nil {
+		s.writeError(ctx, resp, twirp.InternalError("received a nil *SendMetricsResponse and nil error while calling SendMetrics. nil responses are not supported"))
+		return
+	}
+
+	ctx = callResponsePrepared(ctx, s.hooks)
+
+	respBytes, err := respContent.MarshalVT()
+	if err != nil {
+		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal proto response"))
+		return
+	}
+
+	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
+	resp.Header().Set("Content-Type", "application/protobuf")
+	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
+	resp.WriteHeader(http.StatusOK)
+	if n, err := resp.Write(respBytes); err != nil {
+		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
+		twerr := twirp.NewError(twirp.Unknown, msg)
+		ctx = callError(ctx, s.hooks, twerr)
+	}
+	callResponseSent(ctx, s.hooks)
+}
+
 func (s *signalServerServer) serveStartNoiseCancellation(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
 	header := req.Header.Get("Content-Type")
 	i := strings.Index(header, ";")
@@ -3327,86 +3606,94 @@ func callClientError(ctx context.Context, h *twirp.ClientHooks, err twirp.Error)
 }
 
 var twirpFileDescriptor0 = []byte{
-	// 1296 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x58, 0xcb, 0x6e, 0xdb, 0x46,
-	0x17, 0x0e, 0x7d, 0x95, 0x8e, 0x14, 0x47, 0x9e, 0x24, 0xbf, 0x09, 0xe5, 0xcf, 0x8d, 0x6d, 0x10,
-	0x27, 0x4d, 0xe5, 0xda, 0x49, 0xd3, 0xa0, 0x41, 0x83, 0xda, 0x49, 0x50, 0x2b, 0x6d, 0x5a, 0x83,
-	0x74, 0x5c, 0xa0, 0x8b, 0x0a, 0x14, 0x79, 0xe4, 0x10, 0x92, 0x48, 0x76, 0x66, 0xe8, 0xc0, 0xbb,
-	0x22, 0x28, 0x02, 0xf4, 0x15, 0xba, 0xc8, 0x03, 0xf4, 0x79, 0xba, 0xec, 0xc3, 0x14, 0x73, 0x11,
-	0x49, 0xc9, 0xa2, 0x6c, 0x59, 0x2b, 0x8d, 0x66, 0xce, 0xf7, 0x9d, 0xfb, 0x19, 0x92, 0x70, 0xfb,
-	0x28, 0xf0, 0x31, 0xda, 0x60, 0x9d, 0x64, 0x83, 0x05, 0x87, 0xa1, 0xdb, 0x6b, 0xd1, 0xd8, 0xd3,
-	0xcb, 0x46, 0x4c, 0x23, 0x1e, 0x91, 0x35, 0xc6, 0x29, 0xba, 0xfd, 0x86, 0x94, 0x6c, 0xb0, 0x4e,
-	0xd2, 0x50, 0xc7, 0xf5, 0xeb, 0x19, 0xb6, 0x1f, 0xf9, 0xd8, 0x63, 0xfa, 0x47, 0xe1, 0xac, 0x67,
-	0x70, 0xdd, 0xe1, 0x2e, 0xe5, 0x3f, 0x46, 0x01, 0xc3, 0xe7, 0x6e, 0xe8, 0x61, 0xaf, 0xe7, 0xf2,
-	0x20, 0x0a, 0x6d, 0xfc, 0x2d, 0x41, 0xc6, 0xc9, 0x75, 0x00, 0x86, 0x8c, 0x05, 0x51, 0xd8, 0x0a,
-	0x7c, 0xd3, 0xb8, 0x65, 0xac, 0x97, 0xed, 0xb2, 0xde, 0x69, 0xfa, 0xd6, 0x01, 0xdc, 0x28, 0xc2,
-	0xb3, 0x38, 0x0a, 0x19, 0x92, 0x47, 0xb0, 0x88, 0x94, 0x46, 0x54, 0x62, 0x2b, 0x5b, 0x37, 0x1a,
-	0x27, 0x2c, 0xd5, 0x06, 0xbd, 0x14, 0x52, 0xb6, 0x12, 0xb6, 0xbe, 0x81, 0xff, 0x3b, 0x3c, 0x8a,
-	0xcf, 0x6b, 0xd6, 0x1b, 0xe1, 0xd6, 0x58, 0xf8, 0x4c, 0x56, 0xbd, 0x37, 0xa0, 0x6a, 0xa3, 0x17,
-	0x85, 0x21, 0x7a, 0x82, 0x8e, 0xdc, 0x86, 0x2a, 0x0f, 0xfa, 0xd8, 0x62, 0x62, 0xd3, 0x67, 0x92,
-	0x6d, 0xce, 0xae, 0x88, 0x3d, 0x47, 0x6d, 0x91, 0x9f, 0xa0, 0xc4, 0x38, 0x75, 0x39, 0x1e, 0x1e,
-	0x9b, 0x73, 0xb7, 0x8c, 0xf5, 0x95, 0xad, 0x87, 0x85, 0xca, 0x7e, 0xc6, 0x36, 0x8b, 0xbc, 0x2e,
-	0xf2, 0x54, 0x89, 0xa3, 0xa1, 0x76, 0x4a, 0x62, 0xfd, 0x65, 0x40, 0x79, 0x1f, 0x7b, 0xd8, 0x47,
-	0x4e, 0x8f, 0xc9, 0x13, 0x58, 0xcb, 0xec, 0x69, 0x9d, 0x34, 0x66, 0xf7, 0x82, 0x7d, 0x35, 0x13,
-	0xd8, 0xcf, 0x19, 0xf6, 0x3d, 0x54, 0x69, 0xce, 0x17, 0x69, 0x5c, 0x65, 0xeb, 0x4e, 0xa3, 0xa0,
-	0x92, 0x1a, 0x79, 0xc7, 0x77, 0x2f, 0xd8, 0x43, 0xe0, 0x9d, 0x25, 0x58, 0xf0, 0x5d, 0xee, 0x5a,
-	0xff, 0x2c, 0x43, 0xcd, 0xc1, 0xd0, 0x77, 0xb8, 0xcb, 0xd9, 0xd9, 0x92, 0x45, 0xee, 0x41, 0x8d,
-	0x25, 0x6d, 0xe6, 0xd1, 0xa0, 0x8d, 0xb4, 0xc5, 0x04, 0x52, 0x1a, 0x53, 0xb6, 0x2f, 0x65, 0xfb,
-	0x92, 0x90, 0xdc, 0x85, 0x4b, 0x71, 0xd2, 0xee, 0x05, 0xec, 0x6d, 0x2a, 0x39, 0x2f, 0x25, 0x57,
-	0xd2, 0x6d, 0x25, 0x78, 0x07, 0x56, 0xde, 0x61, 0x9b, 0x72, 0xaf, 0x75, 0x84, 0x54, 0xe8, 0x31,
-	0x17, 0xa4, 0xdc, 0x45, 0xb5, 0x7b, 0xa0, 0x36, 0x49, 0x0d, 0xe6, 0x99, 0xdf, 0x35, 0x17, 0xe5,
-	0x99, 0x58, 0x92, 0x9b, 0x50, 0x61, 0x7e, 0x37, 0x45, 0x2d, 0xc9, 0x13, 0x60, 0x7e, 0x77, 0x00,
-	0x79, 0x05, 0x17, 0xdd, 0xc4, 0x0f, 0xa2, 0x96, 0x8f, 0x47, 0x81, 0x87, 0xcc, 0x5c, 0x2e, 0x8a,
-	0x9b, 0x4e, 0x6a, 0x33, 0x8c, 0x13, 0xfe, 0x42, 0x09, 0xdb, 0x55, 0x89, 0xd5, 0xff, 0x04, 0x97,
-	0x14, 0x4f, 0xb9, 0x4a, 0x53, 0x71, 0xc9, 0xe3, 0x01, 0xd7, 0x36, 0x2c, 0xbb, 0xa1, 0x4f, 0xa3,
-	0xc0, 0x37, 0xcb, 0xa7, 0xb0, 0x6c, 0x2b, 0x39, 0x11, 0x29, 0xdc, 0xbd, 0x60, 0x0f, 0x70, 0xe4,
-	0x29, 0x2c, 0xba, 0x71, 0xdc, 0x43, 0x13, 0x24, 0xc1, 0x27, 0xc5, 0x04, 0x42, 0x6a, 0x00, 0x57,
-	0x18, 0xf2, 0x2d, 0x94, 0xf9, 0xa0, 0x2a, 0xcd, 0x8a, 0x24, 0xb0, 0x0a, 0x6b, 0x29, 0xad, 0x5f,
-	0x3b, 0x03, 0x91, 0x27, 0xb0, 0x40, 0x79, 0x3f, 0x36, 0xab, 0x12, 0xfc, 0x69, 0xa1, 0x76, 0x7b,
-	0xff, 0xf5, 0x5e, 0x33, 0x3c, 0xa4, 0xc8, 0x98, 0x2d, 0x11, 0xe4, 0x11, 0x5c, 0xc9, 0x55, 0x90,
-	0xc8, 0xba, 0xaa, 0x8d, 0x8b, 0x22, 0x7b, 0x3b, 0x73, 0xa6, 0x61, 0x93, 0xec, 0xdc, 0xe6, 0x9e,
-	0xaa, 0x91, 0x2d, 0xb8, 0x9c, 0x15, 0x53, 0x06, 0x5a, 0x49, 0x41, 0xab, 0xe9, 0x71, 0x8a, 0xb9,
-	0x06, 0xe5, 0x4c, 0xf2, 0x92, 0x2c, 0x8e, 0x12, 0x1d, 0x1c, 0xfe, 0x00, 0x55, 0x0c, 0xbd, 0xc8,
-	0x47, 0x7d, 0x5e, 0xbb, 0x35, 0xbf, 0x5e, 0xd9, 0xba, 0x57, 0xe8, 0xc8, 0x1e, 0xd2, 0x4e, 0x44,
-	0xfb, 0x62, 0x3e, 0xa9, 0x7e, 0xa9, 0x28, 0x78, 0xca, 0xe6, 0x63, 0x8e, 0x6d, 0x75, 0x6a, 0x36,
-	0x05, 0x57, 0x6c, 0x0f, 0x80, 0x24, 0x61, 0xd0, 0x09, 0xd0, 0x6f, 0xe5, 0x7a, 0x91, 0x48, 0x0f,
-	0x6a, 0xfa, 0xc4, 0x19, 0xb4, 0xe4, 0xce, 0x8a, 0xd0, 0x2d, 0xea, 0x4a, 0xea, 0x46, 0xab, 0x09,
-	0xab, 0xb9, 0xae, 0x9e, 0x69, 0x86, 0x52, 0x58, 0x6d, 0x3e, 0x7f, 0x69, 0x23, 0x13, 0xd7, 0xc6,
-	0x19, 0x27, 0xc4, 0x33, 0x28, 0xc7, 0x88, 0xb4, 0xc5, 0x8f, 0x63, 0xd4, 0x43, 0xf4, 0xf6, 0x84,
-	0x38, 0x20, 0xdd, 0x3f, 0x8e, 0xd1, 0x2e, 0xc5, 0x7a, 0x65, 0xbd, 0x02, 0x92, 0xd7, 0x39, 0xeb,
-	0x1d, 0xb0, 0xf6, 0x26, 0xf6, 0x5d, 0x8e, 0xaf, 0x13, 0xae, 0x9a, 0xe0, 0xac, 0x83, 0x6e, 0x17,
-	0x2a, 0xfd, 0x84, 0xeb, 0x98, 0x8a, 0xc9, 0x25, 0x12, 0x7a, 0xb7, 0xb8, 0x49, 0xa8, 0xeb, 0x75,
-	0x53, 0x25, 0x36, 0xf4, 0x53, 0x7d, 0xd6, 0x1e, 0x98, 0x27, 0x6d, 0x18, 0x75, 0x6b, 0x61, 0x1a,
-	0xb7, 0x02, 0x58, 0x19, 0xd6, 0x47, 0xb6, 0x01, 0xb8, 0xd8, 0x51, 0x51, 0x37, 0x64, 0xd4, 0xad,
-	0x42, 0x32, 0x09, 0x96, 0x61, 0x2f, 0xf3, 0xc1, 0x92, 0x5c, 0x81, 0x45, 0x61, 0xb4, 0x2f, 0x73,
-	0x56, 0xb2, 0xd5, 0x1f, 0x6b, 0x1d, 0x6a, 0xdb, 0x62, 0x0a, 0x0a, 0x55, 0xcf, 0xdf, 0xba, 0xe1,
-	0x21, 0xfa, 0x99, 0xa4, 0x31, 0x22, 0x79, 0x20, 0x14, 0x8d, 0x95, 0x1c, 0xe2, 0xfc, 0x60, 0x40,
-	0x5d, 0x45, 0xc4, 0x51, 0x8d, 0x1e, 0x8b, 0x6b, 0xa9, 0x20, 0x31, 0x73, 0xa3, 0x89, 0x69, 0xc2,
-	0x92, 0x34, 0x7a, 0x90, 0x93, 0xcd, 0xc9, 0x39, 0xc9, 0xab, 0x78, 0x81, 0xdc, 0x0d, 0x7a, 0xcc,
-	0xd6, 0x04, 0x96, 0x03, 0xd7, 0xc6, 0xda, 0x31, 0x53, 0x72, 0xfe, 0x35, 0xc0, 0x2c, 0xd2, 0x4c,
-	0xd6, 0x60, 0x39, 0x61, 0x48, 0xb3, 0x8a, 0x5b, 0x12, 0x7f, 0x9b, 0xfe, 0x69, 0x4e, 0x0f, 0xe7,
-	0x77, 0xfe, 0x3c, 0xf9, 0x7d, 0x09, 0x65, 0x3f, 0xe8, 0x63, 0x98, 0x5e, 0xb0, 0x63, 0xcb, 0x59,
-	0x33, 0xc8, 0x4c, 0xbe, 0x18, 0x88, 0xdb, 0x19, 0xd2, 0xfa, 0xc3, 0x50, 0xe3, 0x65, 0x3b, 0x64,
-	0xef, 0x90, 0x0e, 0x72, 0x36, 0xd4, 0xf4, 0xc6, 0xd4, 0x4d, 0xaf, 0xee, 0xf6, 0x58, 0xfb, 0x2d,
-	0x96, 0x23, 0x01, 0x99, 0x1f, 0x7d, 0x68, 0x7c, 0x05, 0x24, 0x6f, 0xc5, 0x4c, 0x19, 0x53, 0x13,
-	0x67, 0x9f, 0x06, 0x5e, 0xb7, 0x87, 0x33, 0x72, 0xbd, 0x37, 0xe0, 0xb2, 0x83, 0x7c, 0x2f, 0xbd,
-	0x8c, 0x74, 0x80, 0xb4, 0x83, 0x46, 0x91, 0x83, 0x27, 0x32, 0xfe, 0xf5, 0x48, 0x99, 0x9f, 0x92,
-	0xed, 0x66, 0xd8, 0x89, 0xd2, 0xba, 0xfe, 0x68, 0xc0, 0x95, 0x61, 0x23, 0xb4, 0x4f, 0x53, 0x5b,
-	0x71, 0x13, 0x2a, 0xe2, 0x62, 0xa1, 0x6a, 0x1a, 0xcb, 0x34, 0x94, 0x6c, 0x08, 0x3c, 0xd4, 0xf3,
-	0xf9, 0x7c, 0x51, 0xda, 0xfa, 0x58, 0x82, 0xaa, 0x23, 0x9b, 0xd4, 0x41, 0x7a, 0x84, 0x94, 0x74,
-	0xa1, 0x9a, 0x37, 0x98, 0x3c, 0x28, 0x6c, 0xea, 0x31, 0xc1, 0xad, 0x7f, 0x7e, 0x46, 0x69, 0x1d,
-	0x05, 0x04, 0xc8, 0x6a, 0x87, 0xdc, 0x9f, 0x00, 0x1e, 0x29, 0xf3, 0xfa, 0x67, 0x67, 0x92, 0xd5,
-	0x6a, 0x7e, 0x05, 0x68, 0x7a, 0xa8, 0xcb, 0x8a, 0x14, 0x3f, 0xa0, 0x65, 0xb5, 0x37, 0x81, 0x7f,
-	0x4c, 0x81, 0xfe, 0x6e, 0xc0, 0xe5, 0x31, 0xe3, 0x8b, 0x3c, 0x2c, 0x24, 0x29, 0x1e, 0xba, 0xf5,
-	0x47, 0xd3, 0x81, 0xb4, 0x09, 0xef, 0xa0, 0x36, 0x7a, 0xb5, 0x91, 0x2f, 0x4e, 0x61, 0x3a, 0x71,
-	0x13, 0xd7, 0x37, 0xa7, 0x40, 0x64, 0x29, 0x6c, 0x66, 0x45, 0x78, 0x7f, 0x52, 0xd8, 0x86, 0x9f,
-	0x5e, 0x26, 0x87, 0x78, 0xf4, 0xa9, 0xa3, 0x0d, 0xe5, 0xf4, 0x51, 0x8a, 0xdc, 0x9b, 0x98, 0xfc,
-	0xfc, 0x4b, 0x54, 0xfd, 0xfe, 0x59, 0x44, 0xb5, 0x8e, 0x3f, 0x0d, 0xf8, 0xdf, 0xf8, 0xd7, 0x72,
-	0xf2, 0xb8, 0x98, 0x66, 0xd2, 0x77, 0x80, 0xfa, 0x57, 0x53, 0xe3, 0xb4, 0x2d, 0x1f, 0x0c, 0xb8,
-	0x3a, 0xf6, 0x5d, 0x9c, 0x7c, 0x39, 0x81, 0xb2, 0xf8, 0xd5, 0xbf, 0xfe, 0x78, 0x5a, 0x98, 0x32,
-	0x64, 0x27, 0xd8, 0xa9, 0x38, 0x9d, 0x44, 0x8d, 0x88, 0x83, 0xcd, 0x3d, 0xe3, 0x97, 0xa7, 0x87,
-	0x01, 0x7f, 0x9b, 0xb4, 0x1b, 0x5e, 0xd4, 0xdf, 0xf8, 0x0e, 0xc5, 0xab, 0x36, 0xba, 0xfd, 0x0d,
-	0xf9, 0x5d, 0xc4, 0x8b, 0x7a, 0x6a, 0xd1, 0x4e, 0x3a, 0x1b, 0xe3, 0xbe, 0xbe, 0xfc, 0x3d, 0x57,
-	0x57, 0xf2, 0xea, 0x5a, 0x6b, 0x1c, 0x6d, 0x36, 0x9c, 0x4e, 0xd2, 0x50, 0xec, 0xed, 0x25, 0x89,
-	0x7d, 0xf8, 0x5f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xc1, 0x8d, 0xad, 0xb4, 0xb9, 0x11, 0x00, 0x00,
+	// 1417 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x58, 0xdd, 0x72, 0xdb, 0x44,
+	0x14, 0xae, 0xf2, 0xef, 0x63, 0xd7, 0x71, 0xb6, 0x2d, 0xf1, 0xb8, 0xf4, 0x4f, 0xd0, 0x69, 0x1a,
+	0x8a, 0x43, 0xd2, 0x52, 0x3a, 0x74, 0x28, 0x24, 0x6d, 0x87, 0xb8, 0x50, 0x9a, 0x91, 0xd2, 0x30,
+	0xc3, 0x05, 0x1e, 0x59, 0x3a, 0x4e, 0x34, 0xb6, 0x25, 0xb1, 0xbb, 0x4a, 0x27, 0x77, 0x4c, 0x87,
+	0xe9, 0xc0, 0x25, 0xb7, 0x5c, 0xf0, 0x00, 0x3c, 0x0f, 0x97, 0x3c, 0x0c, 0xb3, 0x3f, 0x96, 0x64,
+	0xc7, 0x72, 0xec, 0xe6, 0xca, 0xf2, 0xee, 0xf7, 0x7d, 0xe7, 0xec, 0x39, 0x67, 0xf7, 0xac, 0x04,
+	0xb7, 0x8e, 0x7d, 0x0f, 0xc3, 0x0d, 0xd6, 0x8e, 0x37, 0x98, 0x7f, 0x18, 0x38, 0xdd, 0x26, 0x8d,
+	0x5c, 0xfd, 0x58, 0x8f, 0x68, 0xc8, 0x43, 0xb2, 0xca, 0x38, 0x45, 0xa7, 0x57, 0x97, 0xc8, 0x3a,
+	0x6b, 0xc7, 0x75, 0x35, 0x5d, 0xbb, 0x96, 0x72, 0x7b, 0xa1, 0x87, 0x5d, 0xa6, 0x7f, 0x14, 0xcf,
+	0x7c, 0x02, 0xd7, 0x6c, 0xee, 0x50, 0xfe, 0x43, 0xe8, 0x33, 0x7c, 0xea, 0x04, 0x2e, 0x76, 0xbb,
+	0x0e, 0xf7, 0xc3, 0xc0, 0xc2, 0x5f, 0x62, 0x64, 0x9c, 0x5c, 0x03, 0x60, 0xc8, 0x98, 0x1f, 0x06,
+	0x4d, 0xdf, 0xab, 0x1a, 0x37, 0x8d, 0xb5, 0x82, 0x55, 0xd0, 0x23, 0x0d, 0xcf, 0x3c, 0x80, 0xeb,
+	0x79, 0x7c, 0x16, 0x85, 0x01, 0x43, 0xf2, 0x00, 0xe6, 0x91, 0xd2, 0x90, 0x4a, 0x6e, 0x71, 0xeb,
+	0x7a, 0xfd, 0x94, 0xa7, 0xda, 0xa1, 0xe7, 0x02, 0x65, 0x29, 0xb0, 0xf9, 0x15, 0x7c, 0x68, 0xf3,
+	0x30, 0x7a, 0x5f, 0xb7, 0x5e, 0x8b, 0x65, 0x8d, 0xa4, 0x9f, 0xcb, 0xab, 0xb7, 0x06, 0x94, 0x2c,
+	0x74, 0xc3, 0x20, 0x40, 0x57, 0xc8, 0x91, 0x5b, 0x50, 0xe2, 0x7e, 0x0f, 0x9b, 0x4c, 0x0c, 0x7a,
+	0x4c, 0xaa, 0xcd, 0x58, 0x45, 0x31, 0x66, 0xab, 0x21, 0xf2, 0x0a, 0x96, 0x18, 0xa7, 0x0e, 0xc7,
+	0xc3, 0x93, 0xea, 0xcc, 0x4d, 0x63, 0xad, 0xbc, 0x75, 0x3f, 0xd7, 0xd8, 0x8f, 0xd8, 0x62, 0xa1,
+	0xdb, 0x41, 0x9e, 0x18, 0xb1, 0x35, 0xd5, 0x4a, 0x44, 0xcc, 0xbf, 0x0c, 0x28, 0xec, 0x63, 0x17,
+	0x7b, 0xc8, 0xe9, 0x09, 0x79, 0x04, 0xab, 0xa9, 0x3f, 0xcd, 0xd3, 0xce, 0xec, 0x5e, 0xb0, 0xae,
+	0xa4, 0x80, 0xfd, 0x8c, 0x63, 0xdf, 0x41, 0x89, 0x66, 0xd6, 0x22, 0x9d, 0x2b, 0x6e, 0xdd, 0xae,
+	0xe7, 0x54, 0x52, 0x3d, 0xbb, 0xf0, 0xdd, 0x0b, 0xd6, 0x00, 0x79, 0x67, 0x01, 0xe6, 0x3c, 0x87,
+	0x3b, 0xe6, 0x9f, 0xb3, 0x40, 0x6c, 0x0c, 0xbc, 0x97, 0xc8, 0xa9, 0xef, 0xb2, 0xc9, 0xd2, 0x45,
+	0xee, 0x01, 0x89, 0x03, 0xbf, 0xed, 0xa3, 0xd7, 0xcc, 0xc0, 0x66, 0x24, 0xac, 0xa2, 0x67, 0xec,
+	0x04, 0xfd, 0x35, 0x2c, 0xf9, 0x41, 0x2b, 0x8c, 0xc5, 0x1a, 0x67, 0x6f, 0xce, 0xae, 0x15, 0xb7,
+	0x3e, 0xca, 0x8d, 0x68, 0x43, 0x01, 0x2d, 0x1e, 0x59, 0x09, 0x89, 0xec, 0x40, 0x21, 0x8c, 0xb9,
+	0x56, 0x98, 0x93, 0x0a, 0x1f, 0xe7, 0x2a, 0xbc, 0xd2, 0x48, 0x21, 0x91, 0xd2, 0x88, 0x05, 0xcb,
+	0x14, 0x7b, 0x21, 0xc7, 0x66, 0xe2, 0xcb, 0xbc, 0x54, 0xba, 0x9b, 0xab, 0x64, 0x49, 0x7c, 0xc6,
+	0xa3, 0x32, 0xcd, 0x8e, 0x30, 0xf2, 0x1a, 0x2a, 0x5a, 0x33, 0x75, 0x6f, 0x41, 0x8a, 0xae, 0x9f,
+	0x21, 0x9a, 0x75, 0x52, 0xfb, 0xd5, 0x1f, 0x62, 0xe6, 0x15, 0xb8, 0x34, 0x90, 0x12, 0xb5, 0x05,
+	0xcc, 0x7f, 0x17, 0xa1, 0x22, 0xc6, 0x6d, 0xee, 0xf0, 0x49, 0x13, 0x75, 0x17, 0x2a, 0x2c, 0x6e,
+	0x31, 0x97, 0xfa, 0x2d, 0xa4, 0x4d, 0x26, 0x98, 0x3a, 0x4d, 0xcb, 0xe9, 0xb8, 0x14, 0x24, 0x77,
+	0x60, 0x39, 0x8a, 0x5b, 0x5d, 0x9f, 0x1d, 0x25, 0xc8, 0x59, 0x89, 0x2c, 0x27, 0xc3, 0x0a, 0x78,
+	0x1b, 0xca, 0x6f, 0xb0, 0x45, 0xb9, 0xdb, 0x3c, 0x46, 0x2a, 0xec, 0x54, 0xe7, 0x24, 0xee, 0xa2,
+	0x1a, 0x3d, 0x50, 0x83, 0xa4, 0x02, 0xb3, 0xcc, 0xeb, 0x54, 0xe7, 0xe5, 0x9c, 0x78, 0x24, 0x37,
+	0xa0, 0xc8, 0xbc, 0x4e, 0xc2, 0x5a, 0x90, 0x33, 0xc0, 0xbc, 0x4e, 0x9f, 0xf2, 0x02, 0x2e, 0x3a,
+	0xb1, 0xe7, 0x87, 0x4d, 0x0f, 0x8f, 0x7d, 0x17, 0x59, 0x75, 0x31, 0xaf, 0xc4, 0x93, 0x6a, 0x89,
+	0x62, 0xfe, 0x4c, 0x81, 0xad, 0x92, 0xe4, 0xea, 0x7f, 0x42, 0x4b, 0xc2, 0x13, 0xad, 0xa5, 0xa9,
+	0xb4, 0xe4, 0x74, 0x5f, 0x6b, 0x1b, 0x16, 0x9d, 0xc0, 0xa3, 0xa1, 0xef, 0x55, 0x0b, 0x67, 0xa8,
+	0x6c, 0x2b, 0x9c, 0x88, 0x14, 0xee, 0x5e, 0xb0, 0xfa, 0x3c, 0xf2, 0x18, 0xe6, 0x9d, 0x28, 0xea,
+	0x62, 0x15, 0xa4, 0x40, 0xfe, 0x06, 0xd8, 0x16, 0xa8, 0x3e, 0x5d, 0x71, 0xc8, 0x37, 0x50, 0xe0,
+	0xfd, 0x03, 0xa4, 0x5a, 0x94, 0x02, 0x66, 0xee, 0xb6, 0x4f, 0x8e, 0x1a, 0x2b, 0x25, 0x91, 0x47,
+	0x30, 0x47, 0x79, 0x2f, 0xaa, 0x96, 0x24, 0x39, 0x7f, 0xf3, 0x58, 0xfb, 0x2f, 0xf7, 0x1a, 0xc1,
+	0x21, 0x45, 0xc6, 0x2c, 0xc9, 0x20, 0x0f, 0xe0, 0x72, 0xa6, 0x82, 0x44, 0xd6, 0x55, 0x6d, 0x5c,
+	0x14, 0xd9, 0xdb, 0x99, 0xa9, 0x1a, 0x16, 0x49, 0xe7, 0x2d, 0xee, 0xaa, 0x1a, 0xd9, 0x82, 0x4b,
+	0x69, 0x31, 0xa5, 0xa4, 0x72, 0x42, 0x5a, 0x49, 0xa6, 0x13, 0xce, 0x55, 0x28, 0xa4, 0xc8, 0x65,
+	0x59, 0x1c, 0x4b, 0xb4, 0x3f, 0xf9, 0x3d, 0x94, 0x30, 0x70, 0x43, 0x0f, 0xf5, 0x7c, 0xe5, 0x8c,
+	0xbd, 0xbb, 0x87, 0xb4, 0x1d, 0xd2, 0x9e, 0x68, 0x25, 0x6a, 0xbf, 0x14, 0x15, 0x3d, 0x51, 0xf3,
+	0x30, 0xa3, 0xb6, 0x32, 0xb5, 0x9a, 0xa2, 0x2b, 0xb5, 0xd1, 0xa7, 0x21, 0x19, 0x7d, 0x1a, 0xee,
+	0x94, 0x85, 0x6d, 0x51, 0x57, 0xd2, 0x36, 0x9a, 0x0d, 0x58, 0xc9, 0xec, 0xea, 0x73, 0xb5, 0x3b,
+	0x0a, 0x2b, 0x8d, 0xa7, 0xcf, 0x2d, 0x64, 0xa2, 0xc3, 0x4f, 0x78, 0x42, 0x3c, 0x81, 0x42, 0x84,
+	0x48, 0x9b, 0xfc, 0x24, 0x42, 0xdd, 0xef, 0x6e, 0x8d, 0x89, 0x03, 0xd2, 0xfd, 0x93, 0x08, 0xad,
+	0xa5, 0x48, 0x3f, 0x99, 0x2f, 0x80, 0x64, 0x6d, 0x9e, 0xb7, 0x5d, 0xaf, 0xbe, 0x8e, 0x3c, 0x87,
+	0xe3, 0xcb, 0x98, 0xab, 0x4d, 0x30, 0xe9, 0x41, 0xb7, 0x0b, 0xc5, 0x5e, 0xcc, 0x75, 0x4c, 0xfb,
+	0x6d, 0xe6, 0x4e, 0xfe, 0x26, 0xa1, 0x8e, 0xdb, 0x49, 0x8c, 0x58, 0xd0, 0x4b, 0xec, 0x99, 0x7b,
+	0x50, 0x3d, 0xed, 0xc3, 0xf0, 0xb2, 0xe6, 0xa6, 0x59, 0x96, 0x0f, 0xe5, 0x41, 0x7b, 0x64, 0x1b,
+	0x80, 0x8b, 0x11, 0x15, 0x75, 0x43, 0x46, 0xdd, 0xcc, 0x15, 0x93, 0x64, 0x19, 0xf6, 0x02, 0xef,
+	0x3f, 0x92, 0xcb, 0x30, 0x2f, 0x9c, 0x56, 0x5d, 0x77, 0xc9, 0x52, 0x7f, 0xcc, 0x35, 0xa8, 0x6c,
+	0x8b, 0x53, 0x50, 0x98, 0x7a, 0x7a, 0xe4, 0x04, 0x87, 0xe8, 0xa5, 0x48, 0x63, 0x08, 0x79, 0x20,
+	0x0c, 0x8d, 0x44, 0x0e, 0x68, 0xbe, 0x33, 0xa0, 0xa6, 0x22, 0x62, 0xab, 0x8d, 0x1e, 0x89, 0x1b,
+	0x44, 0x4e, 0x62, 0x66, 0x86, 0x13, 0xd3, 0x80, 0x05, 0xe9, 0x74, 0x3f, 0x27, 0x9b, 0xe3, 0x73,
+	0x92, 0x35, 0xf1, 0x0c, 0xb9, 0xe3, 0x77, 0x99, 0xa5, 0x05, 0x4c, 0x1b, 0xae, 0x8e, 0xf4, 0xe3,
+	0x5c, 0xc9, 0xf9, 0xcf, 0x80, 0x6a, 0x9e, 0x65, 0xb2, 0x0a, 0x8b, 0x31, 0x43, 0x9a, 0x56, 0xdc,
+	0x82, 0xf8, 0xdb, 0xf0, 0xce, 0x5a, 0xf4, 0x60, 0x7e, 0x67, 0xdf, 0x27, 0xbf, 0xcf, 0xa1, 0xe0,
+	0xf9, 0x3d, 0x0c, 0x92, 0x06, 0x3b, 0xb2, 0x9c, 0xb5, 0x82, 0xcc, 0xe4, 0xb3, 0x3e, 0xdc, 0x4a,
+	0x99, 0xe6, 0x6f, 0x86, 0x3a, 0x5e, 0xb6, 0x03, 0xf6, 0x06, 0x69, 0x3f, 0x67, 0x03, 0x9b, 0xde,
+	0x98, 0x7a, 0xd3, 0xab, 0xde, 0x1e, 0xe9, 0x75, 0x8b, 0xc7, 0xa1, 0x80, 0xcc, 0x0e, 0xdf, 0xef,
+	0x5f, 0xa8, 0x5b, 0x66, 0xdf, 0x8b, 0x73, 0x65, 0x4c, 0x9d, 0x38, 0xfb, 0xd4, 0x77, 0x3b, 0x5d,
+	0x3c, 0xa7, 0xd6, 0x5b, 0x43, 0xdc, 0xb5, 0xf8, 0x5e, 0xd2, 0x8c, 0x74, 0x80, 0xf4, 0x02, 0x8d,
+	0xbc, 0x05, 0x9e, 0xca, 0xf8, 0x97, 0x43, 0x65, 0x7e, 0x46, 0xb6, 0x1b, 0x41, 0x3b, 0x4c, 0xea,
+	0xfa, 0x6f, 0x03, 0x2e, 0x0f, 0x3a, 0xa1, 0xd7, 0x34, 0xb5, 0x17, 0x37, 0xa0, 0x28, 0x1a, 0x0b,
+	0x55, 0xa7, 0xb1, 0x4c, 0xc3, 0x92, 0x05, 0xbe, 0x8b, 0xfa, 0x7c, 0x7e, 0xbf, 0x28, 0x6d, 0xfd,
+	0x5e, 0x80, 0x92, 0x2d, 0x37, 0xa9, 0x8d, 0xf4, 0x18, 0x29, 0xe9, 0x40, 0x29, 0xeb, 0x30, 0xb9,
+	0x97, 0xbb, 0xa9, 0x47, 0x04, 0xb7, 0xf6, 0xe9, 0x84, 0x68, 0x1d, 0x05, 0x04, 0x48, 0x6b, 0x87,
+	0xac, 0x8f, 0x21, 0x0f, 0x95, 0x79, 0xed, 0x93, 0x89, 0xb0, 0xda, 0xcc, 0xcf, 0x00, 0x0d, 0x17,
+	0x75, 0x59, 0x91, 0x31, 0x6f, 0x28, 0x49, 0xed, 0x8d, 0xd1, 0x1f, 0x51, 0xa0, 0xbf, 0x1a, 0x70,
+	0x69, 0xc4, 0xf1, 0x45, 0xee, 0xe7, 0x8a, 0xe4, 0x1f, 0xba, 0xb5, 0x07, 0xd3, 0x91, 0xb4, 0x0b,
+	0x6f, 0xa0, 0x32, 0xdc, 0xda, 0xc8, 0x67, 0x67, 0x28, 0x9d, 0xea, 0xc4, 0xb5, 0xcd, 0x29, 0x18,
+	0x69, 0x0a, 0x1b, 0x69, 0x11, 0xae, 0x8f, 0x0b, 0xdb, 0xe0, 0xed, 0x65, 0x7c, 0x88, 0x87, 0x6f,
+	0x1d, 0x2d, 0x28, 0x24, 0x57, 0x29, 0x72, 0x77, 0x6c, 0xf2, 0xb3, 0x2f, 0x51, 0xb5, 0xf5, 0x49,
+	0xa0, 0xda, 0xc6, 0x11, 0x14, 0x33, 0x2f, 0x67, 0x64, 0x7c, 0x89, 0x0d, 0xbe, 0x55, 0xd7, 0xee,
+	0x4d, 0x06, 0xd6, 0x96, 0xfe, 0x30, 0xe0, 0x83, 0xd1, 0xdf, 0x6a, 0xc8, 0xc3, 0x7c, 0xa1, 0x71,
+	0x1f, 0x87, 0x6a, 0x5f, 0x4c, 0xcd, 0xd3, 0xbe, 0xbc, 0x33, 0xe0, 0xca, 0xc8, 0x0f, 0x34, 0xe4,
+	0xf3, 0x31, 0x92, 0xf9, 0xdf, 0x83, 0x6a, 0x0f, 0xa7, 0xa5, 0x29, 0x47, 0x76, 0xfc, 0x9d, 0xa2,
+	0xdd, 0x8e, 0xd5, 0x61, 0x74, 0xb0, 0xb9, 0x67, 0xfc, 0xf4, 0xf8, 0xd0, 0xe7, 0x47, 0x71, 0xab,
+	0xee, 0x86, 0xbd, 0x8d, 0x6f, 0x91, 0xdb, 0x52, 0x75, 0x43, 0x7e, 0x2c, 0x73, 0xc3, 0xae, 0x7a,
+	0x68, 0xc5, 0xed, 0x8d, 0x51, 0x9f, 0xe4, 0xfe, 0x99, 0xa9, 0x29, 0xbc, 0x6a, 0xa0, 0xf5, 0xe3,
+	0xcd, 0xba, 0xdd, 0x8e, 0xeb, 0x4a, 0xbd, 0xb5, 0x20, 0xb9, 0xf7, 0xff, 0x0f, 0x00, 0x00, 0xff,
+	0xff, 0x0b, 0x66, 0x47, 0x6a, 0xce, 0x13, 0x00, 0x00,
 }
diff --git a/protobuf/video/sfu/signal_rpc/signal_vtproto.pb.go b/protobuf/video/sfu/signal_rpc/signal_vtproto.pb.go
index 52e78a201..91d593c56 100644
--- a/protobuf/video/sfu/signal_rpc/signal_vtproto.pb.go
+++ b/protobuf/video/sfu/signal_rpc/signal_vtproto.pb.go
@@ -333,6 +333,182 @@ func (m *Telemetry_Reconnection) MarshalToSizedBufferVT(dAtA []byte) (int, error
 	}
 	return len(dAtA) - i, nil
 }
+func (m *SendMetricsRequest) MarshalVT() (dAtA []byte, err error) {
+	if m == nil {
+		return nil, nil
+	}
+	size := m.SizeVT()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *SendMetricsRequest) MarshalToVT(dAtA []byte) (int, error) {
+	size := m.SizeVT()
+	return m.MarshalToSizedBufferVT(dAtA[:size])
+}
+
+func (m *SendMetricsRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
+	if m == nil {
+		return 0, nil
+	}
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.unknownFields != nil {
+		i -= len(m.unknownFields)
+		copy(dAtA[i:], m.unknownFields)
+	}
+	if len(m.RemoteOutbounds) > 0 {
+		for iNdEx := len(m.RemoteOutbounds) - 1; iNdEx >= 0; iNdEx-- {
+			if marshalto, ok := interface{}(m.RemoteOutbounds[iNdEx]).(interface {
+				MarshalToSizedBufferVT([]byte) (int, error)
+			}); ok {
+				size, err := marshalto.MarshalToSizedBufferVT(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarint(dAtA, i, uint64(size))
+			} else {
+				encoded, err := proto.Marshal(m.RemoteOutbounds[iNdEx])
+				if err != nil {
+					return 0, err
+				}
+				i -= len(encoded)
+				copy(dAtA[i:], encoded)
+				i = encodeVarint(dAtA, i, uint64(len(encoded)))
+			}
+			i--
+			dAtA[i] = 0x32
+		}
+	}
+	if len(m.RemoteInbounds) > 0 {
+		for iNdEx := len(m.RemoteInbounds) - 1; iNdEx >= 0; iNdEx-- {
+			if marshalto, ok := interface{}(m.RemoteInbounds[iNdEx]).(interface {
+				MarshalToSizedBufferVT([]byte) (int, error)
+			}); ok {
+				size, err := marshalto.MarshalToSizedBufferVT(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarint(dAtA, i, uint64(size))
+			} else {
+				encoded, err := proto.Marshal(m.RemoteInbounds[iNdEx])
+				if err != nil {
+					return 0, err
+				}
+				i -= len(encoded)
+				copy(dAtA[i:], encoded)
+				i = encodeVarint(dAtA, i, uint64(len(encoded)))
+			}
+			i--
+			dAtA[i] = 0x2a
+		}
+	}
+	if len(m.Outbounds) > 0 {
+		for iNdEx := len(m.Outbounds) - 1; iNdEx >= 0; iNdEx-- {
+			if marshalto, ok := interface{}(m.Outbounds[iNdEx]).(interface {
+				MarshalToSizedBufferVT([]byte) (int, error)
+			}); ok {
+				size, err := marshalto.MarshalToSizedBufferVT(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarint(dAtA, i, uint64(size))
+			} else {
+				encoded, err := proto.Marshal(m.Outbounds[iNdEx])
+				if err != nil {
+					return 0, err
+				}
+				i -= len(encoded)
+				copy(dAtA[i:], encoded)
+				i = encodeVarint(dAtA, i, uint64(len(encoded)))
+			}
+			i--
+			dAtA[i] = 0x22
+		}
+	}
+	if len(m.Inbounds) > 0 {
+		for iNdEx := len(m.Inbounds) - 1; iNdEx >= 0; iNdEx-- {
+			if marshalto, ok := interface{}(m.Inbounds[iNdEx]).(interface {
+				MarshalToSizedBufferVT([]byte) (int, error)
+			}); ok {
+				size, err := marshalto.MarshalToSizedBufferVT(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarint(dAtA, i, uint64(size))
+			} else {
+				encoded, err := proto.Marshal(m.Inbounds[iNdEx])
+				if err != nil {
+					return 0, err
+				}
+				i -= len(encoded)
+				copy(dAtA[i:], encoded)
+				i = encodeVarint(dAtA, i, uint64(len(encoded)))
+			}
+			i--
+			dAtA[i] = 0x1a
+		}
+	}
+	if len(m.UnifiedSessionId) > 0 {
+		i -= len(m.UnifiedSessionId)
+		copy(dAtA[i:], m.UnifiedSessionId)
+		i = encodeVarint(dAtA, i, uint64(len(m.UnifiedSessionId)))
+		i--
+		dAtA[i] = 0x12
+	}
+	if len(m.SessionId) > 0 {
+		i -= len(m.SessionId)
+		copy(dAtA[i:], m.SessionId)
+		i = encodeVarint(dAtA, i, uint64(len(m.SessionId)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *SendMetricsResponse) MarshalVT() (dAtA []byte, err error) {
+	if m == nil {
+		return nil, nil
+	}
+	size := m.SizeVT()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *SendMetricsResponse) MarshalToVT(dAtA []byte) (int, error) {
+	size := m.SizeVT()
+	return m.MarshalToSizedBufferVT(dAtA[:size])
+}
+
+func (m *SendMetricsResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
+	if m == nil {
+		return 0, nil
+	}
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.unknownFields != nil {
+		i -= len(m.unknownFields)
+		copy(dAtA[i:], m.unknownFields)
+	}
+	return len(dAtA) - i, nil
+}
+
 func (m *SendStatsRequest) MarshalVT() (dAtA []byte, err error) {
 	if m == nil {
 		return nil, nil
@@ -1670,6 +1846,86 @@ func (m *Telemetry_Reconnection) SizeVT() (n int) {
 	}
 	return n
 }
+func (m *SendMetricsRequest) SizeVT() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.SessionId)
+	if l > 0 {
+		n += 1 + l + sov(uint64(l))
+	}
+	l = len(m.UnifiedSessionId)
+	if l > 0 {
+		n += 1 + l + sov(uint64(l))
+	}
+	if len(m.Inbounds) > 0 {
+		for _, e := range m.Inbounds {
+			if size, ok := interface{}(e).(interface {
+				SizeVT() int
+			}); ok {
+				l = size.SizeVT()
+			} else {
+				l = proto.Size(e)
+			}
+			n += 1 + l + sov(uint64(l))
+		}
+	}
+	if len(m.Outbounds) > 0 {
+		for _, e := range m.Outbounds {
+			if size, ok := interface{}(e).(interface {
+				SizeVT() int
+			}); ok {
+				l = size.SizeVT()
+			} else {
+				l = proto.Size(e)
+			}
+			n += 1 + l + sov(uint64(l))
+		}
+	}
+	if len(m.RemoteInbounds) > 0 {
+		for _, e := range m.RemoteInbounds {
+			if size, ok := interface{}(e).(interface {
+				SizeVT() int
+			}); ok {
+				l = size.SizeVT()
+			} else {
+				l = proto.Size(e)
+			}
+			n += 1 + l + sov(uint64(l))
+		}
+	}
+	if len(m.RemoteOutbounds) > 0 {
+		for _, e := range m.RemoteOutbounds {
+			if size, ok := interface{}(e).(interface {
+				SizeVT() int
+			}); ok {
+				l = size.SizeVT()
+			} else {
+				l = proto.Size(e)
+			}
+			n += 1 + l + sov(uint64(l))
+		}
+	}
+	if m.unknownFields != nil {
+		n += len(m.unknownFields)
+	}
+	return n
+}
+
+func (m *SendMetricsResponse) SizeVT() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.unknownFields != nil {
+		n += len(m.unknownFields)
+	}
+	return n
+}
+
 func (m *SendStatsRequest) SizeVT() (n int) {
 	if m == nil {
 		return 0
@@ -2729,6 +2985,340 @@ func (m *Telemetry) UnmarshalVT(dAtA []byte) error {
 	}
 	return nil
 }
+func (m *SendMetricsRequest) UnmarshalVT(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflow
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: SendMetricsRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: SendMetricsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field SessionId", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLength
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLength
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.SessionId = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field UnifiedSessionId", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLength
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLength
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.UnifiedSessionId = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Inbounds", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLength
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLength
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Inbounds = append(m.Inbounds, &models.InboundRtp{})
+			if unmarshal, ok := interface{}(m.Inbounds[len(m.Inbounds)-1]).(interface {
+				UnmarshalVT([]byte) error
+			}); ok {
+				if err := unmarshal.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
+					return err
+				}
+			} else {
+				if err := proto.Unmarshal(dAtA[iNdEx:postIndex], m.Inbounds[len(m.Inbounds)-1]); err != nil {
+					return err
+				}
+			}
+			iNdEx = postIndex
+		case 4:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Outbounds", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLength
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLength
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Outbounds = append(m.Outbounds, &models.OutboundRtp{})
+			if unmarshal, ok := interface{}(m.Outbounds[len(m.Outbounds)-1]).(interface {
+				UnmarshalVT([]byte) error
+			}); ok {
+				if err := unmarshal.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
+					return err
+				}
+			} else {
+				if err := proto.Unmarshal(dAtA[iNdEx:postIndex], m.Outbounds[len(m.Outbounds)-1]); err != nil {
+					return err
+				}
+			}
+			iNdEx = postIndex
+		case 5:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field RemoteInbounds", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLength
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLength
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.RemoteInbounds = append(m.RemoteInbounds, &models.RemoteInboundRtp{})
+			if unmarshal, ok := interface{}(m.RemoteInbounds[len(m.RemoteInbounds)-1]).(interface {
+				UnmarshalVT([]byte) error
+			}); ok {
+				if err := unmarshal.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
+					return err
+				}
+			} else {
+				if err := proto.Unmarshal(dAtA[iNdEx:postIndex], m.RemoteInbounds[len(m.RemoteInbounds)-1]); err != nil {
+					return err
+				}
+			}
+			iNdEx = postIndex
+		case 6:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field RemoteOutbounds", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflow
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLength
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLength
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.RemoteOutbounds = append(m.RemoteOutbounds, &models.RemoteOutboundRtp{})
+			if unmarshal, ok := interface{}(m.RemoteOutbounds[len(m.RemoteOutbounds)-1]).(interface {
+				UnmarshalVT([]byte) error
+			}); ok {
+				if err := unmarshal.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
+					return err
+				}
+			} else {
+				if err := proto.Unmarshal(dAtA[iNdEx:postIndex], m.RemoteOutbounds[len(m.RemoteOutbounds)-1]); err != nil {
+					return err
+				}
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skip(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLength
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *SendMetricsResponse) UnmarshalVT(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflow
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: SendMetricsResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: SendMetricsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		default:
+			iNdEx = preIndex
+			skippy, err := skip(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLength
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
 func (m *SendStatsRequest) UnmarshalVT(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0