diff --git a/BuildScripts~/generate_proto.sh b/BuildScripts~/generate_proto.sh index 308d09bf..2e5005b0 100755 --- a/BuildScripts~/generate_proto.sh +++ b/BuildScripts~/generate_proto.sh @@ -6,13 +6,15 @@ OUT_CSHARP=../Runtime/Scripts/Proto protoc \ -I=$FFI_PROTOCOL \ --csharp_out=$OUT_CSHARP \ - $FFI_PROTOCOL/audio_frame.proto \ - $FFI_PROTOCOL/e2ee.proto \ $FFI_PROTOCOL/ffi.proto \ $FFI_PROTOCOL/handle.proto \ - $FFI_PROTOCOL/participant.proto \ $FFI_PROTOCOL/room.proto \ - $FFI_PROTOCOL/stats.proto \ $FFI_PROTOCOL/track.proto \ + $FFI_PROTOCOL/track_publication.proto \ + $FFI_PROTOCOL/participant.proto \ $FFI_PROTOCOL/video_frame.proto \ - $FFI_PROTOCOL/rpc.proto + $FFI_PROTOCOL/audio_frame.proto \ + $FFI_PROTOCOL/e2ee.proto \ + $FFI_PROTOCOL/stats.proto \ + $FFI_PROTOCOL/rpc.proto \ + $FFI_PROTOCOL/data_stream.proto \ No newline at end of file diff --git a/README.md b/README.md index 6e305316..339bb7b8 100644 --- a/README.md +++ b/README.md @@ -198,7 +198,7 @@ void TrackSubscribed(IRemoteTrack track, RemoteTrackPublication publication, Rem ### RPC -Perform your own predefined method calls from one participant to another. +Perform your own predefined method calls from one participant to another. This feature is especially powerful when used with [Agents](https://docs.livekit.io/agents), for instance to forward LLM function calls to your client application. @@ -235,7 +235,7 @@ IEnumerator PerformRpcCoroutine() Method = "greet", Payload = "Hello from RPC!" }); - + yield return rpcCall; if (rpcCall.IsError) @@ -256,11 +256,174 @@ You may find it useful to adjust the `ResponseTimeout` parameter, which indicate #### Errors -LiveKit is a dynamic realtime environment and RPC calls can fail for various reasons. +LiveKit is a dynamic realtime environment and RPC calls can fail for various reasons. You may throw errors of the type `RpcError` with a string `message` in an RPC method handler and they will be received on the caller's side with the message intact. Other errors will not be transmitted and will instead arrive to the caller as `1500` ("Application Error"). Other built-in errors are detailed in the [docs](https://docs.livekit.io/home/client/data/rpc/#errors). +### Sending text + +Use text streams to send any amount of text between participants. + +#### Sending text all at once + +```cs +IEnumerator PerformSendText() +{ + var text = "Lorem ipsum dolor sit amet..."; + var sendTextCall = room.LocalParticipant.SendText(text, "some-topic"); + yield return sendTextCall; + + Debug.Log($"Sent text with stream ID {sendTextCall.Info.Id}"); +} +``` + +#### Streaming text incrementally + +```cs +IEnumerator PerformStreamText() +{ + var streamTextCall = room.LocalParticipant.StreamText("my-topic"); + yield return streamTextCall; + + var writer = streamTextCall.Writer; + Debug.Log($"Opened text stream with ID: {writer.Info.Id}"); + + // In a real app, you would generate this text asynchronously / incrementally as well + var textChunks = new[] { "Lorem ", "ipsum ", "dolor ", "sit ", "amet..." }; + foreach (var chunk in textChunks) + { + yield return writer.Write(chunk); + } + + // The stream must be explicitly closed when done + yield return writer.Close(); + + Debug.Log($"Closed text stream with ID: {writer.Info.Id}"); +} +``` + +#### Handling incoming streams + +```cs +IEnumerator HandleTextStream(TextStreamReader reader, string participantIdentity) +{ + var info = reader.Info; + Debug.Log($@" + Text stream received from {participantIdentity} + Topic: {info.Topic} + Timestamp: {info.Timestamp} + ID: {info.Id} + Size: {info.TotalLength} (only available if the stream was sent with `SendText`) + "); + + // Option 1: Process the stream incrementally + var readIncremental = reader.ReadIncremental(); + while (!readIncremental.IsEos) + { + readIncremental.Reset(); + yield return readIncremental; + Debug.Log($"Next chunk: {readIncremental.Text}"); + } + + // Option 2: Get the entire text after the stream completes + var readAllCall = reader.ReadAll(); + yield return readAllCall; + Debug.Log($"Received text: {readAllCall.Text}") +} + +// Register the topic before connecting to the room +room.RegisterTextStreamHandler("my-topic", (reader, identity) => + StartCoroutine(HandleTextStream(reader, identity)) +); +``` + +### Sending files & bytes + +Use byte streams to send files, images, or any other kind of data between participants. + +#### Sending files + +```cs +IEnumerator PerformSendFile() +{ + var filePath = "path/to/file.jpg"; + var sendFileCall = room.LocalParticipant.SendFile(filePath, "some-topic"); + yield return sendFileCall; + + Debug.Log($"Sent file with stream ID: {sendFileCall.Info.Id}"); +} +``` + +#### Streaming bytes + +```cs +IEnumerator PerformStreamBytes() +{ + var streamBytesCall = room.LocalParticipant.StreamBytes("my-topic"); + yield return streamBytesCall; + + var writer = streamBytesCall.Writer; + Debug.Log($"Opened byte stream with ID: {writer.Info.Id}"); + + // Example sending arbitrary binary data + // For sending files, use `SendFile` instead + var dataChunks = new[] { + new byte[] { 0x00, 0x01 }, + new byte[] { 0x03, 0x04 } + }; + foreach (var chunk in dataChunks) + { + yield return writer.Write(chunk); + } + + // The stream must be explicitly closed when done + yield return writer.Close(); + + Debug.Log($"Closed byte stream with ID: {writer.Info.Id}"); +} +``` + +#### Handling incoming streams +```cs +IEnumerator HandleByteStream(ByteStreamReader reader, string participantIdentity) +{ + var info = reader.Info; + + // Option 1: Process the stream incrementally + var readIncremental = reader.ReadIncremental(); + while (!readIncremental.IsEos) + { + readIncremental.Reset(); + yield return readIncremental; + Debug.Log($"Next chunk: {readIncremental.Bytes}"); + } + + // Option 2: Get the entire file after the stream completes + var readAllCall = reader.ReadAll(); + yield return readAllCall; + var data = readAllCall.Bytes; + + // Option 3: Write the stream to a local file on disk as it arrives + var writeToFileCall = reader.WriteToFile(); + yield return writeToFileCall; + var path = writeToFileCall.FilePath; + Debug.Log($"Wrote to file: {path}"); + + Debug.Log($@" + Byte stream received from {participantIdentity} + Topic: {info.Topic} + Timestamp: {info.Timestamp} + ID: {info.Id} + Size: {info.TotalLength} (only available if the stream was sent with `SendFile`) + "); +} + +// Register the topic after connection to the room +room.RegisterByteStreamHandler("my-topic", (reader, identity) => + StartCoroutine(HandleByteStream(reader, identity)) +); +```
diff --git a/Runtime/Plugins/ffi-ios-arm64/liblivekit_ffi.a b/Runtime/Plugins/ffi-ios-arm64/liblivekit_ffi.a index e671cc75..2b240650 100644 --- a/Runtime/Plugins/ffi-ios-arm64/liblivekit_ffi.a +++ b/Runtime/Plugins/ffi-ios-arm64/liblivekit_ffi.a @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:739851187aa82b80cccb6f54b8051d21f41ed2950bb04c69707809ef54a638e6 -size 389770720 +oid sha256:0faf50c97678a0e7cc14ba44fa9388600c989d34f5eba10c43b20c098c8ea02c +size 390456280 diff --git a/Runtime/Plugins/ffi-ios-sim-arm64/liblivekit_ffi.a b/Runtime/Plugins/ffi-ios-sim-arm64/liblivekit_ffi.a index 00ea141a..fcdb16f4 100644 --- a/Runtime/Plugins/ffi-ios-sim-arm64/liblivekit_ffi.a +++ b/Runtime/Plugins/ffi-ios-sim-arm64/liblivekit_ffi.a @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:5522f18ce78eb1f50cb4ca7e3769196defc8539f7c441fba260159152029525c -size 390225536 +oid sha256:2060a7550703e2d6f3902294aab6a7d35e6365388c7c54897033581710384b6b +size 390952040 diff --git a/Runtime/Plugins/ffi-linux-arm64/liblivekit_ffi.so b/Runtime/Plugins/ffi-linux-arm64/liblivekit_ffi.so index 5c0d766e..9a4ce346 100644 --- a/Runtime/Plugins/ffi-linux-arm64/liblivekit_ffi.so +++ b/Runtime/Plugins/ffi-linux-arm64/liblivekit_ffi.so @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:9fb3fbf5f1ee14627ac4cbade4c01d0bbbc618871a33fa86d3cc0a1ceeb9ee3c -size 22431680 +oid sha256:d8f2197a320a325c45991a8d4fac73c0afed21af231b5629025bc6295d2d8072 +size 22892808 diff --git a/Runtime/Plugins/ffi-linux-x86_64/liblivekit_ffi.so b/Runtime/Plugins/ffi-linux-x86_64/liblivekit_ffi.so index 990885ab..3b863a85 100644 --- a/Runtime/Plugins/ffi-linux-x86_64/liblivekit_ffi.so +++ b/Runtime/Plugins/ffi-linux-x86_64/liblivekit_ffi.so @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:fd951fec55fd911b5c5579ed11e23b62232e3ef37d2b6cd4ab3df60039004bcc -size 28248048 +oid sha256:900fee3e36c07a58aa04a0fc4e8c638e526be1feaf7f6166e0f77ba4311c5cb1 +size 28893512 diff --git a/Runtime/Plugins/ffi-macos-arm64/liblivekit_ffi.dylib b/Runtime/Plugins/ffi-macos-arm64/liblivekit_ffi.dylib index 3aafcb46..4f693dac 100644 --- a/Runtime/Plugins/ffi-macos-arm64/liblivekit_ffi.dylib +++ b/Runtime/Plugins/ffi-macos-arm64/liblivekit_ffi.dylib @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:6bab83c74518c607ad63663a0bbeba5b7ba3273c99be23aa480d96050e71dcd0 -size 19029584 +oid sha256:809c8df28fbcce2a8f97a479e0f43594c347eebb03f56b8a391281e3b5c3c4e6 +size 19481568 diff --git a/Runtime/Plugins/ffi-macos-x86_64/liblivekit_ffi.dylib b/Runtime/Plugins/ffi-macos-x86_64/liblivekit_ffi.dylib index 7704cc93..1e6649c0 100644 --- a/Runtime/Plugins/ffi-macos-x86_64/liblivekit_ffi.dylib +++ b/Runtime/Plugins/ffi-macos-x86_64/liblivekit_ffi.dylib @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:91f61ac6942f40137dd6132f3769c584b3e916a51b9930a635c809b39abeb366 -size 23943212 +oid sha256:ec17d30409e1f02454504a9436f158177ee65231d802c792b4f28a21308fc7f8 +size 24491668 diff --git a/Runtime/Plugins/ffi-windows-arm64/livekit_ffi.dll b/Runtime/Plugins/ffi-windows-arm64/livekit_ffi.dll index 3d602b8b..11bd586f 100644 --- a/Runtime/Plugins/ffi-windows-arm64/livekit_ffi.dll +++ b/Runtime/Plugins/ffi-windows-arm64/livekit_ffi.dll @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:9cfe667483e9d15a4d85cd09b45bc748e793d4cc58bd9fa3328db942c6815d5a -size 19950592 +oid sha256:0ae9e59502a4c77502f15d6ee144e62985a0aeee5542721b966a701f84259db1 +size 20545536 diff --git a/Runtime/Plugins/ffi-windows-x86_64/livekit_ffi.dll b/Runtime/Plugins/ffi-windows-x86_64/livekit_ffi.dll index 9bb93b16..f9abaf5c 100644 --- a/Runtime/Plugins/ffi-windows-x86_64/livekit_ffi.dll +++ b/Runtime/Plugins/ffi-windows-x86_64/livekit_ffi.dll @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:848f5c47f7f67ab524bf5c89b9167f820670146e42dc76929c5461d96b1328a4 -size 26507264 +oid sha256:edc94f69b5647a73890ce44818d3bf1a9003681f8572b4b6bbebcc07ffc279b2 +size 27193344 diff --git a/Runtime/Scripts/DataStream.cs b/Runtime/Scripts/DataStream.cs new file mode 100644 index 00000000..b41becfe --- /dev/null +++ b/Runtime/Scripts/DataStream.cs @@ -0,0 +1,901 @@ +using System; +using System.Collections.Generic; +using LiveKit.Internal.FFIClients.Requests; +using System.Linq; +using System.Threading.Tasks; +using LiveKit.Internal; +using LiveKit.Proto; + +namespace LiveKit +{ + /// + /// Information about a data stream. + /// + public class StreamInfo + { + /// + /// Unique identifier of the stream. + /// + public string Id { get; } + + /// + /// Topic name used to route the stream to the appropriate handler. + /// + public string Topic { get; } + + /// + /// When the stream was created. + /// + public DateTime Timestamp { get; } + + /// + /// Total expected size in bytes, if known. + /// + public ulong? TotalLength { get; } + + /// + /// Additional attributes as needed for your application. + /// + public IReadOnlyDictionary Attributes { get; } + + /// + /// The MIME type of the stream data. + /// + public string MimeType { get; } + + internal StreamInfo( + string id, + string topic, + long timestamp, + ulong? totalLength, + Google.Protobuf.Collections.MapField attributes, + string mimeType) + { + Id = id; + Topic = topic; + Timestamp = DateTimeOffset.FromUnixTimeMilliseconds(timestamp).DateTime; + TotalLength = totalLength; + Attributes = attributes.ToDictionary(kvp => kvp.Key, kvp => kvp.Value); + MimeType = mimeType; + } + } + + /// + /// Information about a text data stream. + /// + public sealed class TextStreamInfo : StreamInfo + { + /// + /// Operation type for text streams. + /// + public enum OperationType + { + Create = 0, + Update = 1, + Delete = 2, + Reaction = 3 + } + + public OperationType Operation { get; } + public int Version { get; } + public string ReplyToStreamId { get; } + public IReadOnlyList AttachedStreamIds { get; } + public bool Generated { get; } + + internal TextStreamInfo(Proto.TextStreamInfo proto) : base( + proto.StreamId, + proto.Topic, + proto.Timestamp, + proto.TotalLength, + proto.Attributes, + proto.MimeType) + { + Operation = (OperationType)proto.OperationType; + Version = proto.Version; + ReplyToStreamId = proto.ReplyToStreamId; + AttachedStreamIds = proto.AttachedStreamIds; + Generated = proto.Generated; + } + } + + /// + /// Information about a byte data stream. + /// + public sealed class ByteStreamInfo : StreamInfo + { + public string Name { get; } + + internal ByteStreamInfo(Proto.ByteStreamInfo proto) : base( + proto.StreamId, + proto.Topic, + proto.Timestamp, + proto.TotalLength, + proto.Attributes, + proto.MimeType) + { + Name = proto.Name; + } + } + + /// + /// Delegate for handling incoming text data streams. + /// + public delegate void TextStreamHandler(TextStreamReader reader, string identity); + + /// + /// Delegate for handling incoming byte data streams. + /// + public delegate void ByteStreamHandler(ByteStreamReader reader, string identity); + + /// + /// Error for data stream operations. + /// + public sealed class StreamError : Exception + { + public StreamError(string message) : base(message) { } + + internal StreamError(Proto.StreamError proto) : base(proto.Description) { } + } + + /// + /// Reader for an incoming text data stream. + /// + public sealed class TextStreamReader + { + private readonly FfiHandle _handle; + private readonly TextStreamInfo _info; + + internal TextStreamReader(OwnedTextStreamReader info) + { + _handle = FfiHandle.FromOwnedHandle(info.Handle); + _info = new TextStreamInfo(info.Info); + } + + public TextStreamInfo Info => _info; + + /// + /// Reads all incoming chunks from the stream, concatenating them into a single value + /// once the stream closes normally. + /// + /// Calling this method consumes the stream reader. + /// + /// A that completes when the stream is complete or errors. + /// Check and access + /// properties to handle the result. + /// + public ReadAllInstruction ReadAll() + { + using var request = FFIBridge.Instance.NewRequest(); + var readAllReq = request.request; + readAllReq.ReaderHandle = (ulong)_handle.DangerousGetHandle(); + + using var response = request.Send(); + FfiResponse res = response; + return new ReadAllInstruction(res.TextReadAll.AsyncId); + } + + /// + /// YieldInstruction for . + /// + /// + /// Access after checking + /// + public sealed class ReadAllInstruction : YieldInstruction + { + private ulong _asyncId; + private string _text; + + internal ReadAllInstruction(ulong asyncId) + { + _asyncId = asyncId; + FfiClient.Instance.TextStreamReaderReadAllReceived += OnReadAll; + } + + internal void OnReadAll(TextStreamReaderReadAllCallback e) + { + if (e.AsyncId != _asyncId) + return; + + switch (e.ResultCase) + { + case TextStreamReaderReadAllCallback.ResultOneofCase.Error: + Error = new StreamError(e.Error); + IsError = true; + break; + case TextStreamReaderReadAllCallback.ResultOneofCase.Content: + _text = e.Content; + break; + } + IsDone = true; + FfiClient.Instance.TextStreamReaderReadAllReceived -= OnReadAll; + } + + public string Text + { + get + { + if (IsError) throw Error; + return _text; + } + } + + public StreamError Error { get; private set; } + } + + /// + /// Reads incoming chunks from the stream incrementally. + /// + /// + /// A that allows reading the stream incrementally. + /// + public ReadIncrementalInstruction ReadIncremental() + { + using var request = FFIBridge.Instance.NewRequest(); + var readIncReq = request.request; + readIncReq.ReaderHandle = (ulong)_handle.DangerousGetHandle(); + request.Send(); + + return new ReadIncrementalInstruction(_handle); + } + + /// + /// YieldInstruction for . + /// + /// + /// Usage: while is false (i.e. the stream has not ended), + /// call , yield the instruction, and then access . + /// + public sealed class ReadIncrementalInstruction : StreamYieldInstruction + { + private readonly FfiHandle _handle; + private string _latestChunk; + + internal ReadIncrementalInstruction(FfiHandle readerHandle) + { + _handle = readerHandle; + FfiClient.Instance.TextStreamReaderEventReceived += OnStreamEvent; + } + + private void OnStreamEvent(TextStreamReaderEvent e) + { + if (e.ReaderHandle != (ulong)_handle.DangerousGetHandle()) + return; + + switch (e.DetailCase) + { + case TextStreamReaderEvent.DetailOneofCase.ChunkReceived: + _latestChunk = e.ChunkReceived.Content; + IsCurrentReadDone = true; + break; + case TextStreamReaderEvent.DetailOneofCase.Eos: + IsEos = true; + if (e.Eos.Error != null) + { + Error = new StreamError(e.Eos.Error); + } + FfiClient.Instance.TextStreamReaderEventReceived -= OnStreamEvent; + break; + } + } + + public string Text + { + get + { + if (Error != null) throw Error; + return _latestChunk; + } + } + + /// + /// True if an error occurred on the last read. + /// + public bool IsError => Error != null; + + /// + /// Error that occurred on the last read, if any. + /// + public StreamError Error { get; private set; } + } + } + + /// + /// Reader for an incoming byte data stream. + /// + public sealed class ByteStreamReader + { + private FfiHandle _handle; + private readonly ByteStreamInfo _info; + + internal ByteStreamReader(OwnedByteStreamReader info) + { + _handle = FfiHandle.FromOwnedHandle(info.Handle); + _info = new ByteStreamInfo(info.Info); + } + + public ByteStreamInfo Info => _info; + + /// + /// Reads all incoming chunks from the stream, concatenating them into a single value + /// once the stream closes normally. + /// + /// Calling this method consumes the stream reader. + /// + /// A that completes when the stream is complete or errors. + /// Check and access + /// properties to handle the result. + /// + public ReadAllInstruction ReadAll() + { + using var request = FFIBridge.Instance.NewRequest(); + var readAllReq = request.request; + readAllReq.ReaderHandle = (ulong)_handle.DangerousGetHandle(); + + using var response = request.Send(); + FfiResponse res = response; + return new ReadAllInstruction(res.ByteReadAll.AsyncId); + } + + /// + /// Reads incoming chunks from the stream incrementally. + /// + /// + /// A that allows reading the stream incrementally. + /// + public ReadIncrementalInstruction ReadIncremental() + { + using var request = FFIBridge.Instance.NewRequest(); + var readIncReq = request.request; + readIncReq.ReaderHandle = (ulong)_handle.DangerousGetHandle(); + request.Send(); + + return new ReadIncrementalInstruction(_handle); + } + + /// + /// Reads incoming chunks from the byte stream, writing them to a file as they are received. + /// + /// The directory to write the file in. The system temporary directory is used if not specified. + /// The name to use for the written file, overriding stream name. + /// + /// Calling this method consumes the stream reader. + /// + /// + /// A that completes when the stream is complete or errors. + /// Check and access + /// properties to handle the result. + /// + public WriteToFileInstruction WriteToFile(string directory = null, string nameOverride = null) + { + using var request = FFIBridge.Instance.NewRequest(); + var writeToFileReq = request.request; + writeToFileReq.ReaderHandle = (ulong)_handle.DangerousGetHandle(); + writeToFileReq.Directory = directory; + writeToFileReq.NameOverride = nameOverride; + + using var response = request.Send(); + FfiResponse res = response; + return new WriteToFileInstruction(res.ByteWriteToFile.AsyncId); + } + + /// + /// YieldInstruction for . + /// + /// + /// Access after checking + /// + public sealed class ReadAllInstruction : YieldInstruction + { + private ulong _asyncId; + private byte[] _bytes; + + internal ReadAllInstruction(ulong asyncId) + { + _asyncId = asyncId; + FfiClient.Instance.ByteStreamReaderReadAllReceived += OnReadAll; + } + + internal void OnReadAll(ByteStreamReaderReadAllCallback e) + { + if (e.AsyncId != _asyncId) + return; + + switch (e.ResultCase) + { + case ByteStreamReaderReadAllCallback.ResultOneofCase.Error: + Error = new StreamError(e.Error); + IsError = true; + break; + case ByteStreamReaderReadAllCallback.ResultOneofCase.Content: + _bytes = e.Content.ToArray(); + break; + } + IsDone = true; + FfiClient.Instance.ByteStreamReaderReadAllReceived -= OnReadAll; + } + + public byte[] Bytes + { + get + { + if (IsError) throw Error; + return _bytes; + } + } + + public StreamError Error { get; private set; } + } + + /// + /// YieldInstruction for . + /// + /// + /// Usage: while is false (i.e. the stream has not ended), + /// call , yield the instruction, and then access . + /// + public sealed class ReadIncrementalInstruction : StreamYieldInstruction + { + private readonly FfiHandle _handle; + private byte[] _latestChunk; + + internal ReadIncrementalInstruction(FfiHandle readerHandle) + { + _handle = readerHandle; + FfiClient.Instance.ByteStreamReaderEventReceived += OnStreamEvent; + } + + private void OnStreamEvent(ByteStreamReaderEvent e) + { + if (e.ReaderHandle != (ulong)_handle.DangerousGetHandle()) + return; + + switch (e.DetailCase) + { + case ByteStreamReaderEvent.DetailOneofCase.ChunkReceived: + _latestChunk = e.ChunkReceived.Content.ToByteArray(); + IsCurrentReadDone = true; + break; + case ByteStreamReaderEvent.DetailOneofCase.Eos: + IsEos = true; + if (e.Eos.Error != null) + { + Error = new StreamError(e.Eos.Error); + } + FfiClient.Instance.ByteStreamReaderEventReceived -= OnStreamEvent; + break; + } + } + + public byte[] Bytes + { + get + { + if (Error != null) throw Error; + return _latestChunk; + } + } + + /// + /// True if an error occurred on the last read. + /// + public bool IsError => Error != null; + + /// + /// Error that occurred on the last read, if any. + /// + public StreamError Error { get; private set; } + } + + /// + /// YieldInstruction for . + /// + /// + /// Access after checking + /// + public sealed class WriteToFileInstruction : YieldInstruction + { + private ulong _asyncId; + private string _filePath; + + internal WriteToFileInstruction(ulong asyncId) + { + _asyncId = asyncId; + FfiClient.Instance.ByteStreamReaderWriteToFileReceived += OnWriteToFile; + } + + internal void OnWriteToFile(ByteStreamReaderWriteToFileCallback e) + { + if (e.AsyncId != _asyncId) + return; + + switch (e.ResultCase) + { + case ByteStreamReaderWriteToFileCallback.ResultOneofCase.Error: + Error = new StreamError(e.Error); + IsError = true; + break; + case ByteStreamReaderWriteToFileCallback.ResultOneofCase.FilePath: + _filePath = e.FilePath; + break; + } + IsDone = true; + FfiClient.Instance.ByteStreamReaderWriteToFileReceived -= OnWriteToFile; + } + + /// + /// Path to the file that was written. + /// + public string FilePath + { + get + { + if (IsError) throw Error; + return _filePath; + } + } + + public StreamError Error { get; private set; } + } + } + + /// + /// Options used when opening an outgoing data stream. + /// + public class StreamOptions + { + public string Topic { get; set; } + public IDictionary Attributes { get; set; } = new Dictionary(); + public List DestinationIdentities { get; set; } = new List(); + public string Id { get; set; } + } + + /// + /// Options used when opening an outgoing text data stream. + /// + public class StreamTextOptions : StreamOptions + { + public TextStreamInfo.OperationType? OperationType { get; set; } + public int? Version { get; set; } + public string ReplyToStreamId { get; set; } + public List AttachedStreamIds { get; set; } = new List(); + public bool? Generated { get; set; } + + internal Proto.StreamTextOptions ToProto() + { + var proto = new Proto.StreamTextOptions(); + if (Topic == null) + { + throw new InvalidOperationException("Topic field is required"); + } + proto.Topic = Topic; + proto.Attributes.Add(Attributes); + proto.DestinationIdentities.AddRange(DestinationIdentities); + + // TODO: these fields are optional, but the generated proto is not allowing null values + if (Id != null) proto.Id = Id; + if (OperationType != null) proto.OperationType = (Proto.TextStreamInfo.Types.OperationType)OperationType; + if (Version != null) proto.Version = Version.Value; + if (ReplyToStreamId != null) proto.ReplyToStreamId = ReplyToStreamId; + proto.AttachedStreamIds.AddRange(AttachedStreamIds); + if (Generated != null) proto.Generated = Generated.Value; + return proto; + } + } + + /// + /// Options used when opening an outgoing byte data stream. + /// + public class StreamByteOptions : StreamOptions + { + public string MimeType { get; set; } + public string Name { get; set; } + public ulong? TotalLength { get; set; } + + internal Proto.StreamByteOptions ToProto() + { + var proto = new Proto.StreamByteOptions(); + if (Topic == null) + { + throw new InvalidOperationException("Topic field is required"); + } + proto.Topic = Topic; + proto.Attributes.Add(Attributes); + proto.DestinationIdentities.AddRange(DestinationIdentities); + // TODO: these fields are optional, but the generated proto is not allowing null values + if (Id != null) proto.Id = Id; + if (MimeType != null) proto.MimeType = MimeType; + if (Name != null) proto.Name = Name; + if (TotalLength != null) proto.TotalLength = TotalLength.Value; + return proto; + } + } + + /// + /// Writer for an outgoing text data stream. + /// + public class TextStreamWriter + { + private FfiHandle _handle; + private readonly TextStreamInfo _info; + + internal TextStreamWriter(OwnedTextStreamWriter info) + { + _handle = FfiHandle.FromOwnedHandle(info.Handle); + _info = new TextStreamInfo(info.Info); + } + + public TextStreamInfo Info => _info; + + /// + /// Writes text to the stream. + /// + /// The text to write. + /// + /// A that completes when the write operation is complete or errors. + /// Check to see if the operation was successful. + /// + public WriteInstruction Write(string text) + { + using var request = FFIBridge.Instance.NewRequest(); + var writeReq = request.request; + writeReq.WriterHandle = (ulong)_handle.DangerousGetHandle(); + writeReq.Text = text; + + using var response = request.Send(); + FfiResponse res = response; + return new WriteInstruction(res.TextStreamWrite.AsyncId); + } + + /// + /// Closes the stream. + /// + /// A string specifying the reason for closure, if the stream is not being closed normally. + /// + /// A that completes when the close operation is complete or errors. + /// Check to see if the operation was successful. + /// + public CloseInstruction Close(string reason = null) + { + using var request = FFIBridge.Instance.NewRequest(); + var closeReq = request.request; + closeReq.WriterHandle = (ulong)_handle.DangerousGetHandle(); + closeReq.Reason = reason; + + using var response = request.Send(); + FfiResponse res = response; + return new CloseInstruction(res.TextStreamWrite.AsyncId); + } + + /// + /// YieldInstruction for . + /// + /// + /// Check if the operation was successful by accessing . + /// + public sealed class WriteInstruction : YieldInstruction + { + private ulong _asyncId; + + internal WriteInstruction(ulong asyncId) + { + _asyncId = asyncId; + FfiClient.Instance.ByteStreamWriterWriteReceived += OnWrite; + } + + internal void OnWrite(ByteStreamWriterWriteCallback e) + { + if (e.AsyncId != _asyncId) + return; + + if (e.Error != null) + { + Error = new StreamError(e.Error); + IsError = true; + } + IsDone = true; + FfiClient.Instance.ByteStreamWriterWriteReceived -= OnWrite; + } + + public StreamError Error { get; private set; } + } + + /// + /// YieldInstruction for . + /// + /// + /// Check if the operation was successful by accessing . + /// + public sealed class CloseInstruction : YieldInstruction + { + private ulong _asyncId; + + internal CloseInstruction(ulong asyncId) + { + _asyncId = asyncId; + FfiClient.Instance.ByteStreamWriterCloseReceived += OnClose; + } + + internal void OnClose(ByteStreamWriterCloseCallback e) + { + if (e.AsyncId != _asyncId) + return; + + if (e.Error != null) + { + Error = new StreamError(e.Error); + IsError = true; + } + IsDone = true; + FfiClient.Instance.ByteStreamWriterCloseReceived -= OnClose; + } + + public StreamError Error { get; private set; } + } + } + + /// + /// Writer for an outgoing byte data stream. + /// + public class ByteStreamWriter + { + private FfiHandle _handle; + private readonly ByteStreamInfo _info; + + internal ByteStreamWriter(OwnedByteStreamWriter info) + { + _handle = FfiHandle.FromOwnedHandle(info.Handle); + _info = new ByteStreamInfo(info.Info); + } + + public ByteStreamInfo Info => _info; + + /// + /// Writes bytes to the stream. + /// + /// The bytes to write. + /// + /// A that completes when the write operation is complete or errors. + /// + public WriteInstruction Write(byte[] bytes) + { + using var request = FFIBridge.Instance.NewRequest(); + var writeReq = request.request; + writeReq.WriterHandle = (ulong)_handle.DangerousGetHandle(); + writeReq.Bytes = Google.Protobuf.ByteString.CopyFrom(bytes); + + using var response = request.Send(); + FfiResponse res = response; + return new WriteInstruction(res.ByteStreamWrite.AsyncId); + } + + /// + /// Closes the stream. + /// + /// A string specifying the reason for closure, if the stream is not being closed normally. + /// + /// A that completes when the close operation is complete or errors. + /// + public CloseInstruction Close(string reason = null) + { + using var request = FFIBridge.Instance.NewRequest(); + var closeReq = request.request; + closeReq.WriterHandle = (ulong)_handle.DangerousGetHandle(); + closeReq.Reason = reason; + + using var response = request.Send(); + FfiResponse res = response; + return new CloseInstruction(res.ByteStreamWrite.AsyncId); + } + + /// + /// YieldInstruction for . + /// + /// + /// Check if the operation was successful by accessing . + /// + public sealed class WriteInstruction : YieldInstruction + { + private ulong _asyncId; + + internal WriteInstruction(ulong asyncId) + { + _asyncId = asyncId; + FfiClient.Instance.TextStreamWriterWriteReceived += OnWrite; + } + + internal void OnWrite(TextStreamWriterWriteCallback e) + { + if (e.AsyncId != _asyncId) + return; + + if (e.Error != null) + { + Error = new StreamError(e.Error); + IsError = true; + } + IsDone = true; + FfiClient.Instance.TextStreamWriterWriteReceived -= OnWrite; + } + + public StreamError Error { get; private set; } + } + + /// + /// YieldInstruction for . + /// + /// + /// Check if the operation was successful by accessing . + /// + public sealed class CloseInstruction : YieldInstruction + { + private ulong _asyncId; + + internal CloseInstruction(ulong asyncId) + { + _asyncId = asyncId; + FfiClient.Instance.TextStreamWriterCloseReceived += OnClose; + } + + internal void OnClose(TextStreamWriterCloseCallback e) + { + if (e.AsyncId != _asyncId) + return; + + if (e.Error != null) + { + Error = new StreamError(e.Error); + IsError = true; + } + IsDone = true; + FfiClient.Instance.TextStreamWriterCloseReceived -= OnClose; + } + + public StreamError Error { get; private set; } + } + } + + internal sealed class StreamHandlerRegistry + { + private readonly Dictionary _textStreamHandlers = new(); + private readonly Dictionary _byteStreamHandlers = new(); + + internal void RegisterTextStreamHandler(string topic, TextStreamHandler handler) + { + if (!_textStreamHandlers.TryAdd(topic, handler)) + { + throw new StreamError($"Text stream handler already registered for topic: {topic}"); + } + } + + internal void RegisterByteStreamHandler(string topic, ByteStreamHandler handler) + { + if (!_byteStreamHandlers.TryAdd(topic, handler)) + { + throw new StreamError($"Byte stream handler already registered for topic: {topic}"); + } + } + + internal void UnregisterTextStreamHandler(string topic) => _textStreamHandlers.Remove(topic); + internal void UnregisterByteStreamHandler(string topic) => _byteStreamHandlers.Remove(topic); + + internal bool Dispatch(TextStreamReader reader, string participantIdentity) + { + if (_textStreamHandlers.TryGetValue(reader.Info.Topic, out var handler)) + { + handler(reader, participantIdentity); + return true; + } + return false; + } + + internal bool Dispatch(ByteStreamReader reader, string participantIdentity) + { + if (_byteStreamHandlers.TryGetValue(reader.Info.Topic, out var handler)) + { + handler(reader, participantIdentity); + return true; + } + return false; + } + } +} \ No newline at end of file diff --git a/Runtime/Scripts/DataStream.cs.meta b/Runtime/Scripts/DataStream.cs.meta new file mode 100644 index 00000000..b0716f0e --- /dev/null +++ b/Runtime/Scripts/DataStream.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 87d7370f2615f41c49056eca4cacee1d +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Runtime/Scripts/Internal/FFIClient.cs b/Runtime/Scripts/Internal/FFIClient.cs index d55901cc..de47274b 100644 --- a/Runtime/Scripts/Internal/FFIClient.cs +++ b/Runtime/Scripts/Internal/FFIClient.cs @@ -46,6 +46,20 @@ internal sealed class FfiClient : IFFIClient public event PerformRpcReceivedDelegate? PerformRpcReceived; + public event ByteStreamReaderEventReceivedDelegate? ByteStreamReaderEventReceived; + public event ByteStreamReaderReadAllReceivedDelegate? ByteStreamReaderReadAllReceived; + public event ByteStreamReaderWriteToFileReceivedDelegate? ByteStreamReaderWriteToFileReceived; + public event ByteStreamOpenReceivedDelegate? ByteStreamOpenReceived; + public event ByteStreamWriterWriteReceivedDelegate? ByteStreamWriterWriteReceived; + public event ByteStreamWriterCloseReceivedDelegate? ByteStreamWriterCloseReceived; + public event SendFileReceivedDelegate? SendFileReceived; + public event TextStreamReaderEventReceivedDelegate? TextStreamReaderEventReceived; + public event TextStreamReaderReadAllReceivedDelegate? TextStreamReaderReadAllReceived; + public event TextStreamOpenReceivedDelegate? TextStreamOpenReceived; + public event TextStreamWriterWriteReceivedDelegate? TextStreamWriterWriteReceived; + public event TextStreamWriterCloseReceivedDelegate? TextStreamWriterCloseReceived; + public event SendTextReceivedDelegate? SendTextReceived; + public FfiClient() : this(Pools.NewFfiResponsePool(), new ArrayMemoryPool()) { } @@ -195,7 +209,7 @@ out UIntPtr dataLen { // Since we are in a thread I want to make sure we catch and log Utils.Error(e); - // But we aren't actually handling this exception so we should re-throw here + // But we aren't actually handling this exception so we should re-throw here throw new Exception("Cannot send request", e); } } @@ -265,6 +279,46 @@ static unsafe void FFICallback(UIntPtr data, UIntPtr size) case FfiEvent.MessageOneofCase.PerformRpc: Instance.PerformRpcReceived?.Invoke(r.PerformRpc!); break; + // Uses high-level data stream interface + case FfiEvent.MessageOneofCase.ByteStreamReaderEvent: + Instance.ByteStreamReaderEventReceived?.Invoke(r.ByteStreamReaderEvent!); + break; + case FfiEvent.MessageOneofCase.ByteStreamReaderReadAll: + Instance.ByteStreamReaderReadAllReceived?.Invoke(r.ByteStreamReaderReadAll!); + break; + case FfiEvent.MessageOneofCase.ByteStreamReaderWriteToFile: + Instance.ByteStreamReaderWriteToFileReceived?.Invoke(r.ByteStreamReaderWriteToFile!); + break; + case FfiEvent.MessageOneofCase.ByteStreamOpen: + Instance.ByteStreamOpenReceived?.Invoke(r.ByteStreamOpen!); + break; + case FfiEvent.MessageOneofCase.ByteStreamWriterWrite: + Instance.ByteStreamWriterWriteReceived?.Invoke(r.ByteStreamWriterWrite!); + break; + case FfiEvent.MessageOneofCase.ByteStreamWriterClose: + Instance.ByteStreamWriterCloseReceived?.Invoke(r.ByteStreamWriterClose!); + break; + case FfiEvent.MessageOneofCase.SendFile: + Instance.SendFileReceived?.Invoke(r.SendFile!); + break; + case FfiEvent.MessageOneofCase.TextStreamReaderEvent: + Instance.TextStreamReaderEventReceived?.Invoke(r.TextStreamReaderEvent!); + break; + case FfiEvent.MessageOneofCase.TextStreamReaderReadAll: + Instance.TextStreamReaderReadAllReceived?.Invoke(r.TextStreamReaderReadAll!); + break; + case FfiEvent.MessageOneofCase.TextStreamOpen: + Instance.TextStreamOpenReceived?.Invoke(r.TextStreamOpen!); + break; + case FfiEvent.MessageOneofCase.TextStreamWriterWrite: + Instance.TextStreamWriterWriteReceived?.Invoke(r.TextStreamWriterWrite!); + break; + case FfiEvent.MessageOneofCase.TextStreamWriterClose: + Instance.TextStreamWriterCloseReceived?.Invoke(r.TextStreamWriterClose!); + break; + case FfiEvent.MessageOneofCase.SendText: + Instance.SendTextReceived?.Invoke(r.SendText!); + break; case FfiEvent.MessageOneofCase.Panic: break; default: diff --git a/Runtime/Scripts/Internal/FFIClients/FFIEvents.cs b/Runtime/Scripts/Internal/FFIClients/FFIEvents.cs index cd58ce8c..8f2490e0 100644 --- a/Runtime/Scripts/Internal/FFIClients/FFIEvents.cs +++ b/Runtime/Scripts/Internal/FFIClients/FFIEvents.cs @@ -21,7 +21,29 @@ namespace LiveKit.Internal internal delegate void DisconnectReceivedDelegate(DisconnectCallback e); internal delegate void GetSessionStatsDelegate(GetStatsCallback e); - + + internal delegate void ByteStreamReaderReadAllReceivedDelegate(ByteStreamReaderReadAllCallback e); + + internal delegate void ByteStreamReaderWriteToFileReceivedDelegate(ByteStreamReaderWriteToFileCallback e); + + internal delegate void ByteStreamOpenReceivedDelegate(ByteStreamOpenCallback e); + + internal delegate void ByteStreamWriterWriteReceivedDelegate(ByteStreamWriterWriteCallback e); + + internal delegate void ByteStreamWriterCloseReceivedDelegate(ByteStreamWriterCloseCallback e); + + internal delegate void SendFileReceivedDelegate(StreamSendFileCallback e); + + internal delegate void TextStreamReaderReadAllReceivedDelegate(TextStreamReaderReadAllCallback e); + + internal delegate void TextStreamOpenReceivedDelegate(TextStreamOpenCallback e); + + internal delegate void TextStreamWriterWriteReceivedDelegate(TextStreamWriterWriteCallback e); + + internal delegate void TextStreamWriterCloseReceivedDelegate(TextStreamWriterCloseCallback e); + + internal delegate void SendTextReceivedDelegate(StreamSendTextCallback e); + // Events internal delegate void RoomEventReceivedDelegate(RoomEvent e); @@ -38,4 +60,8 @@ namespace LiveKit.Internal internal delegate void PerformRpcReceivedDelegate(PerformRpcCallback e); + + internal delegate void ByteStreamReaderEventReceivedDelegate(ByteStreamReaderEvent e); + + internal delegate void TextStreamReaderEventReceivedDelegate(TextStreamReaderEvent e); } \ No newline at end of file diff --git a/Runtime/Scripts/Internal/FFIClients/FfiRequestExtensions.cs b/Runtime/Scripts/Internal/FFIClients/FfiRequestExtensions.cs index 03eb7958..e6a4716b 100644 --- a/Runtime/Scripts/Internal/FFIClients/FfiRequestExtensions.cs +++ b/Runtime/Scripts/Internal/FFIClients/FfiRequestExtensions.cs @@ -100,6 +100,46 @@ public static void Inject(this FfiRequest ffiRequest, T request) case RpcMethodInvocationResponseRequest rpcMethodInvocationResponseRequest: ffiRequest.RpcMethodInvocationResponse = rpcMethodInvocationResponseRequest; break; + // Data stream + case TextStreamReaderReadIncrementalRequest textStreamReaderReadIncrementalRequest: + ffiRequest.TextReadIncremental = textStreamReaderReadIncrementalRequest; + break; + case TextStreamReaderReadAllRequest textStreamReaderReadAllRequest: + ffiRequest.TextReadAll = textStreamReaderReadAllRequest; + break; + case ByteStreamReaderReadIncrementalRequest byteStreamReaderReadIncrementalRequest: + ffiRequest.ByteReadIncremental = byteStreamReaderReadIncrementalRequest; + break; + case ByteStreamReaderReadAllRequest byteStreamReaderReadAllRequest: + ffiRequest.ByteReadAll = byteStreamReaderReadAllRequest; + break; + case ByteStreamReaderWriteToFileRequest byteStreamReaderWriteToFileRequest: + ffiRequest.ByteWriteToFile = byteStreamReaderWriteToFileRequest; + break; + case StreamSendFileRequest streamSendFileRequest: + ffiRequest.SendFile = streamSendFileRequest; + break; + case StreamSendTextRequest streamSendTextRequest: + ffiRequest.SendText = streamSendTextRequest; + break; + case ByteStreamOpenRequest byteStreamOpenRequest: + ffiRequest.ByteStreamOpen = byteStreamOpenRequest; + break; + case ByteStreamWriterWriteRequest byteStreamWriterWriteRequest: + ffiRequest.ByteStreamWrite = byteStreamWriterWriteRequest; + break; + case ByteStreamWriterCloseRequest byteStreamWriterCloseRequest: + ffiRequest.ByteStreamClose = byteStreamWriterCloseRequest; + break; + case TextStreamOpenRequest textStreamOpenRequest: + ffiRequest.TextStreamOpen = textStreamOpenRequest; + break; + case TextStreamWriterWriteRequest textStreamWriterWriteRequest: + ffiRequest.TextStreamWrite = textStreamWriterWriteRequest; + break; + case TextStreamWriterCloseRequest textStreamWriterCloseRequest: + ffiRequest.TextStreamClose = textStreamWriterCloseRequest; + break; default: throw new Exception($"Unknown request type: {request?.GetType().FullName ?? "null"}"); } diff --git a/Runtime/Scripts/Internal/YieldInstruction.cs b/Runtime/Scripts/Internal/YieldInstruction.cs index 2afa8551..97cbb807 100644 --- a/Runtime/Scripts/Internal/YieldInstruction.cs +++ b/Runtime/Scripts/Internal/YieldInstruction.cs @@ -1,3 +1,4 @@ +using System; using UnityEngine; namespace LiveKit @@ -9,4 +10,31 @@ public class YieldInstruction : CustomYieldInstruction public override bool keepWaiting => !IsDone; } + + public class StreamYieldInstruction : CustomYieldInstruction + { + /// + /// True if the stream has reached the end. + /// + public bool IsEos { protected set; get; } + + internal bool IsCurrentReadDone { get; set; } + + public override bool keepWaiting => !IsCurrentReadDone && !IsEos; + + /// + /// Resets the yield instruction for the next read. + /// + /// + /// Calling this method after is true will throw an exception. + /// + public override void Reset() + { + if (IsEos) + { + throw new InvalidOperationException("Cannot reset after end of stream"); + } + IsCurrentReadDone = false; + } + } } diff --git a/Runtime/Scripts/Participant.cs b/Runtime/Scripts/Participant.cs index dd0e8ba3..bc610cd4 100644 --- a/Runtime/Scripts/Participant.cs +++ b/Runtime/Scripts/Participant.cs @@ -6,6 +6,7 @@ using LiveKit.Internal; using LiveKit.Proto; using LiveKit.Internal.FFIClients.Requests; +using System.Diagnostics; namespace LiveKit { @@ -175,8 +176,8 @@ public PerformRpcInstruction PerformRpc(PerformRpcParams rpcParams) /// Registers a new RPC method handler. /// /// The name of the RPC method to register - /// The async callback that handles incoming RPC requests. It receives an RpcInvocationData object - /// containing the caller's identity, payload (up to 15KiB UTF-8), and response timeout. Must return a string response or throw + /// The async callback that handles incoming RPC requests. It receives an RpcInvocationData object + /// containing the caller's identity, payload (up to 15KiB UTF-8), and response timeout. Must return a string response or throw /// an RpcError. Any other exceptions will be converted to a generic APPLICATION_ERROR (1500). public void RegisterRpcMethod(string method, RpcHandler handler) { @@ -293,6 +294,188 @@ private unsafe void PublishData(byte* data, int len, IReadOnlyCollection Utils.Debug("Sending message: " + topic); var response = request.Send(); } + + /// + /// Send text to participants in the room. + /// + /// The text content to send. + /// Configuration options for the text stream, including topic and + /// destination participants. + /// + /// A that completes when the text is sent or errors. + /// Check and access + /// properties to handle the result. + /// + /// + public SendTextInstruction SendText(string text, StreamTextOptions options) + { + using var request = FFIBridge.Instance.NewRequest(); + var sendTextReq = request.request; + sendTextReq.LocalParticipantHandle = (ulong)Handle.DangerousGetHandle(); + sendTextReq.Text = text; + sendTextReq.Options = options.ToProto(); + + using var response = request.Send(); + FfiResponse res = response; + return new SendTextInstruction(res.SendText.AsyncId); + } + + /// + /// Send text to participants in the room. + /// + /// The text content to send. + /// Topic identifier used to route the stream to appropriate handlers. + /// + /// Use the overload to set custom stream options. + /// + /// + /// A that completes when the text is sent or errors. + /// Check and access + /// properties to handle the result. + /// + /// + public SendTextInstruction SendText(string text, string topic) + { + var options = new StreamTextOptions(); + options.Topic = topic; + return SendText(text, options); + } + + /// + /// Send a file on disk to participants in the room. + /// + /// Path to the file to be sent. + /// Configuration options for the byte stream, including topic and + /// destination participants. + /// + /// A that completes when the file is sent or errors. + /// Check and access + /// properties to handle the result. + /// + /// + public SendFileInstruction SendFile(string path, StreamByteOptions options) + { + using var request = FFIBridge.Instance.NewRequest(); + var sendFileReq = request.request; + sendFileReq.LocalParticipantHandle = (ulong)Handle.DangerousGetHandle(); + sendFileReq.FilePath = path; + sendFileReq.Options = options.ToProto(); + + using var response = request.Send(); + FfiResponse res = response; + return new SendFileInstruction(res.SendFile.AsyncId); + } + + /// + /// Send a file on disk to participants in the room. + /// + /// Path to the file to be sent. + /// Topic identifier used to route the stream to appropriate handlers. + /// + /// Use the overload to set custom stream options. + /// + /// + /// A that completes when the file is sent or errors. + /// Check and access + /// properties to handle the result. + /// + /// + public SendFileInstruction SendFile(string path, string topic) + { + var options = new StreamByteOptions(); + options.Topic = topic; + return SendFile(path, options); + } + + /// + /// Stream text incrementally to participants in the room. + /// + /// + /// This method allows sending text data in chunks as it becomes available. + /// Unlike , which sends the entire text at once, this method allows + /// using a writer to send text incrementally. + /// + /// Configuration options for the text stream, including topic and + /// destination participants. + /// + /// A that completes once the stream is open or errors. + /// Check and access + /// to access the writer for the opened stream. + /// + public StreamTextInstruction StreamText(StreamTextOptions options) + { + using var request = FFIBridge.Instance.NewRequest(); + var streamTextReq = request.request; + streamTextReq.LocalParticipantHandle = (ulong)Handle.DangerousGetHandle(); + streamTextReq.Options = options.ToProto(); + + using var response = request.Send(); + FfiResponse res = response; + return new StreamTextInstruction(res.TextStreamOpen.AsyncId); + } + + /// + /// Stream bytes incrementally to participants in the room. + /// + /// + /// This method allows sending byte data in chunks as it becomes available. + /// Unlike , which sends the entire file at once, this method allows + /// using a writer to send byte data incrementally. + /// + /// Configuration options for the byte stream, including topic and + /// destination participants. + /// + /// A that completes once the stream is open or errors. + /// Check and access + /// to access the writer for the opened stream. + /// + public StreamBytesInstruction StreamBytes(StreamByteOptions options) + { + using var request = FFIBridge.Instance.NewRequest(); + var streamBytesReq = request.request; + streamBytesReq.LocalParticipantHandle = (ulong)Handle.DangerousGetHandle(); + streamBytesReq.Options = options.ToProto(); + + using var response = request.Send(); + FfiResponse res = response; + return new StreamBytesInstruction(res.ByteStreamOpen.AsyncId); + } + + /// + /// Stream bytes to participants in the room. + /// + /// + /// Use the overload to set custom stream options. + /// + /// Topic identifier used to route the stream to appropriate handlers. + /// + /// A that completes once the stream is open or errors. + /// Check and access + /// to access the writer for the opened stream. + /// + public StreamBytesInstruction StreamBytes(string topic) + { + var options = new StreamByteOptions { Topic = topic }; + return StreamBytes(options); + } + + /// + /// Stream text to participants in the room. + /// + /// + /// Use the overload to set custom stream options. + /// + /// Topic identifier used to route the stream to appropriate handlers. + /// + /// A that completes once the stream is open or errors. + /// Check and access + /// to access the writer for the opened stream. + /// + public StreamTextInstruction StreamText(string topic) + { + var options = new StreamTextOptions { Topic = topic }; + return StreamText(options); + } } public sealed class RemoteParticipant : Participant @@ -411,4 +594,196 @@ public string Payload /// public RpcError Error { get; private set; } } + + /// + /// YieldInstruction for send text. Returned by . + /// + /// + /// Access after checking + /// + public sealed class SendTextInstruction : YieldInstruction + { + private ulong _asyncId; + private TextStreamInfo _info; + + internal SendTextInstruction(ulong asyncId) + { + _asyncId = asyncId; + FfiClient.Instance.SendTextReceived += OnSendText; + } + + internal void OnSendText(StreamSendTextCallback e) + { + if (e.AsyncId != _asyncId) + return; + + switch (e.ResultCase) + { + case StreamSendTextCallback.ResultOneofCase.Error: + Error = new StreamError(e.Error); + IsError = true; + break; + case StreamSendTextCallback.ResultOneofCase.Info: + _info = new TextStreamInfo(e.Info); + break; + } + IsDone = true; + FfiClient.Instance.SendTextReceived -= OnSendText; + } + + public TextStreamInfo Info + { + get + { + if (IsError) throw Error; + return _info; + } + } + + public StreamError Error { get; private set; } + } + + /// + /// YieldInstruction for send file. Returned by . + /// + /// + /// Access after checking + /// + public sealed class SendFileInstruction : YieldInstruction + { + private ulong _asyncId; + private ByteStreamInfo _info; + + internal SendFileInstruction(ulong asyncId) + { + _asyncId = asyncId; + FfiClient.Instance.SendFileReceived += OnSendFile; + } + + internal void OnSendFile(StreamSendFileCallback e) + { + if (e.AsyncId != _asyncId) + return; + + switch (e.ResultCase) + { + case StreamSendFileCallback.ResultOneofCase.Error: + Error = new StreamError(e.Error); + IsError = true; + break; + case StreamSendFileCallback.ResultOneofCase.Info: + _info = new ByteStreamInfo(e.Info); + break; + } + IsDone = true; + FfiClient.Instance.SendFileReceived -= OnSendFile; + } + + public ByteStreamInfo Info + { + get + { + if (IsError) throw Error; + return _info; + } + } + + public StreamError Error { get; private set; } + } + + /// + /// YieldInstruction for stream text. Returned by . + /// + /// + /// Access after checking + /// + public sealed class StreamTextInstruction : YieldInstruction + { + private ulong _asyncId; + private TextStreamWriter _writer; + + internal StreamTextInstruction(ulong asyncId) + { + _asyncId = asyncId; + FfiClient.Instance.TextStreamOpenReceived += OnStreamOpen; + } + + internal void OnStreamOpen(TextStreamOpenCallback e) + { + if (e.AsyncId != _asyncId) + return; + + switch (e.ResultCase) + { + case TextStreamOpenCallback.ResultOneofCase.Error: + Error = new StreamError(e.Error); + IsError = true; + break; + case TextStreamOpenCallback.ResultOneofCase.Writer: + _writer = new TextStreamWriter(e.Writer); + break; + } + IsDone = true; + FfiClient.Instance.TextStreamOpenReceived -= OnStreamOpen; + } + + public TextStreamWriter Writer + { + get + { + if (IsError) throw Error; + return _writer; + } + } + + public StreamError Error { get; private set; } + } + + /// + /// YieldInstruction for stream bytes. Returned by . + /// + /// + /// Access after checking + /// + public sealed class StreamBytesInstruction : YieldInstruction + { + private ulong _asyncId; + private ByteStreamWriter _writer; + + internal StreamBytesInstruction(ulong asyncId) + { + _asyncId = asyncId; + FfiClient.Instance.ByteStreamOpenReceived += OnStreamOpen; + } + + internal void OnStreamOpen(ByteStreamOpenCallback e) + { + if (e.AsyncId != _asyncId) + return; + + switch (e.ResultCase) + { + case ByteStreamOpenCallback.ResultOneofCase.Error: + Error = new StreamError(e.Error); + IsError = true; + break; + case ByteStreamOpenCallback.ResultOneofCase.Writer: + _writer = new ByteStreamWriter(e.Writer); + break; + } + IsDone = true; + FfiClient.Instance.ByteStreamOpenReceived -= OnStreamOpen; + } + + public ByteStreamWriter Writer + { + get + { + if (IsError) throw Error; + return _writer; + } + } + + public StreamError Error { get; private set; } + } } diff --git a/Runtime/Scripts/Proto/AudioFrame.cs b/Runtime/Scripts/Proto/AudioFrame.cs index ad11d265..b6455ed1 100644 --- a/Runtime/Scripts/Proto/AudioFrame.cs +++ b/Runtime/Scripts/Proto/AudioFrame.cs @@ -25,98 +25,120 @@ static AudioFrameReflection() { byte[] descriptorData = global::System.Convert.FromBase64String( string.Concat( "ChFhdWRpb19mcmFtZS5wcm90bxINbGl2ZWtpdC5wcm90bxoMaGFuZGxlLnBy", - "b3RvGgt0cmFjay5wcm90byKGAQoVTmV3QXVkaW9TdHJlYW1SZXF1ZXN0EhQK", + "b3RvGgt0cmFjay5wcm90byLEAQoVTmV3QXVkaW9TdHJlYW1SZXF1ZXN0EhQK", "DHRyYWNrX2hhbmRsZRgBIAIoBBIsCgR0eXBlGAIgAigOMh4ubGl2ZWtpdC5w", "cm90by5BdWRpb1N0cmVhbVR5cGUSEwoLc2FtcGxlX3JhdGUYAyABKA0SFAoM", - "bnVtX2NoYW5uZWxzGAQgASgNIkkKFk5ld0F1ZGlvU3RyZWFtUmVzcG9uc2US", - "LwoGc3RyZWFtGAEgAigLMh8ubGl2ZWtpdC5wcm90by5Pd25lZEF1ZGlvU3Ry", - "ZWFtIsoBCiFBdWRpb1N0cmVhbUZyb21QYXJ0aWNpcGFudFJlcXVlc3QSGgoS", - "cGFydGljaXBhbnRfaGFuZGxlGAEgAigEEiwKBHR5cGUYAiACKA4yHi5saXZl", - "a2l0LnByb3RvLkF1ZGlvU3RyZWFtVHlwZRIwCgx0cmFja19zb3VyY2UYAyAB", - "KA4yGi5saXZla2l0LnByb3RvLlRyYWNrU291cmNlEhMKC3NhbXBsZV9yYXRl", - "GAUgASgNEhQKDG51bV9jaGFubmVscxgGIAEoDSJVCiJBdWRpb1N0cmVhbUZy", - "b21QYXJ0aWNpcGFudFJlc3BvbnNlEi8KBnN0cmVhbRgBIAIoCzIfLmxpdmVr", - "aXQucHJvdG8uT3duZWRBdWRpb1N0cmVhbSK7AQoVTmV3QXVkaW9Tb3VyY2VS", - "ZXF1ZXN0EiwKBHR5cGUYASACKA4yHi5saXZla2l0LnByb3RvLkF1ZGlvU291", - "cmNlVHlwZRIyCgdvcHRpb25zGAIgASgLMiEubGl2ZWtpdC5wcm90by5BdWRp", - "b1NvdXJjZU9wdGlvbnMSEwoLc2FtcGxlX3JhdGUYAyACKA0SFAoMbnVtX2No", - "YW5uZWxzGAQgAigNEhUKDXF1ZXVlX3NpemVfbXMYBSABKA0iSQoWTmV3QXVk", - "aW9Tb3VyY2VSZXNwb25zZRIvCgZzb3VyY2UYASACKAsyHy5saXZla2l0LnBy", - "b3RvLk93bmVkQXVkaW9Tb3VyY2UiZgoYQ2FwdHVyZUF1ZGlvRnJhbWVSZXF1", - "ZXN0EhUKDXNvdXJjZV9oYW5kbGUYASACKAQSMwoGYnVmZmVyGAIgAigLMiMu", - "bGl2ZWtpdC5wcm90by5BdWRpb0ZyYW1lQnVmZmVySW5mbyItChlDYXB0dXJl", - "QXVkaW9GcmFtZVJlc3BvbnNlEhAKCGFzeW5jX2lkGAEgAigEIjwKGUNhcHR1", - "cmVBdWRpb0ZyYW1lQ2FsbGJhY2sSEAoIYXN5bmNfaWQYASACKAQSDQoFZXJy", - "b3IYAiABKAkiMAoXQ2xlYXJBdWRpb0J1ZmZlclJlcXVlc3QSFQoNc291cmNl", - "X2hhbmRsZRgBIAIoBCIaChhDbGVhckF1ZGlvQnVmZmVyUmVzcG9uc2UiGgoY", - "TmV3QXVkaW9SZXNhbXBsZXJSZXF1ZXN0IlIKGU5ld0F1ZGlvUmVzYW1wbGVy", - "UmVzcG9uc2USNQoJcmVzYW1wbGVyGAEgAigLMiIubGl2ZWtpdC5wcm90by5P", - "d25lZEF1ZGlvUmVzYW1wbGVyIpMBChdSZW1peEFuZFJlc2FtcGxlUmVxdWVz", - "dBIYChByZXNhbXBsZXJfaGFuZGxlGAEgAigEEjMKBmJ1ZmZlchgCIAIoCzIj", - "LmxpdmVraXQucHJvdG8uQXVkaW9GcmFtZUJ1ZmZlckluZm8SFAoMbnVtX2No", - "YW5uZWxzGAMgAigNEhMKC3NhbXBsZV9yYXRlGAQgAigNIlAKGFJlbWl4QW5k", - "UmVzYW1wbGVSZXNwb25zZRI0CgZidWZmZXIYASACKAsyJC5saXZla2l0LnBy", - "b3RvLk93bmVkQXVkaW9GcmFtZUJ1ZmZlciKcAgoWTmV3U294UmVzYW1wbGVy", - "UmVxdWVzdBISCgppbnB1dF9yYXRlGAEgAigBEhMKC291dHB1dF9yYXRlGAIg", - "AigBEhQKDG51bV9jaGFubmVscxgDIAIoDRI8Cg9pbnB1dF9kYXRhX3R5cGUY", - "BCACKA4yIy5saXZla2l0LnByb3RvLlNveFJlc2FtcGxlckRhdGFUeXBlEj0K", - "EG91dHB1dF9kYXRhX3R5cGUYBSACKA4yIy5saXZla2l0LnByb3RvLlNveFJl", - "c2FtcGxlckRhdGFUeXBlEjcKDnF1YWxpdHlfcmVjaXBlGAYgAigOMh8ubGl2", - "ZWtpdC5wcm90by5Tb3hRdWFsaXR5UmVjaXBlEg0KBWZsYWdzGAcgASgNImwK", - "F05ld1NveFJlc2FtcGxlclJlc3BvbnNlEjUKCXJlc2FtcGxlchgBIAEoCzIg", - "LmxpdmVraXQucHJvdG8uT3duZWRTb3hSZXNhbXBsZXJIABIPCgVlcnJvchgC", - "IAEoCUgAQgkKB21lc3NhZ2UiUwoXUHVzaFNveFJlc2FtcGxlclJlcXVlc3QS", - "GAoQcmVzYW1wbGVyX2hhbmRsZRgBIAIoBBIQCghkYXRhX3B0chgCIAIoBBIM", - "CgRzaXplGAMgAigNIksKGFB1c2hTb3hSZXNhbXBsZXJSZXNwb25zZRISCgpv", - "dXRwdXRfcHRyGAEgAigEEgwKBHNpemUYAiACKA0SDQoFZXJyb3IYAyABKAki", - "NAoYRmx1c2hTb3hSZXNhbXBsZXJSZXF1ZXN0EhgKEHJlc2FtcGxlcl9oYW5k", - "bGUYASACKAQiTAoZRmx1c2hTb3hSZXNhbXBsZXJSZXNwb25zZRISCgpvdXRw", - "dXRfcHRyGAEgAigEEgwKBHNpemUYAiACKA0SDQoFZXJyb3IYAyABKAkicAoU", - "QXVkaW9GcmFtZUJ1ZmZlckluZm8SEAoIZGF0YV9wdHIYASACKAQSFAoMbnVt", - "X2NoYW5uZWxzGAIgAigNEhMKC3NhbXBsZV9yYXRlGAMgAigNEhsKE3NhbXBs", - "ZXNfcGVyX2NoYW5uZWwYBCACKA0ieQoVT3duZWRBdWRpb0ZyYW1lQnVmZmVy", - "Ei0KBmhhbmRsZRgBIAIoCzIdLmxpdmVraXQucHJvdG8uRmZpT3duZWRIYW5k", - "bGUSMQoEaW5mbxgCIAIoCzIjLmxpdmVraXQucHJvdG8uQXVkaW9GcmFtZUJ1", - "ZmZlckluZm8iPwoPQXVkaW9TdHJlYW1JbmZvEiwKBHR5cGUYASACKA4yHi5s", - "aXZla2l0LnByb3RvLkF1ZGlvU3RyZWFtVHlwZSJvChBPd25lZEF1ZGlvU3Ry", - "ZWFtEi0KBmhhbmRsZRgBIAIoCzIdLmxpdmVraXQucHJvdG8uRmZpT3duZWRI", - "YW5kbGUSLAoEaW5mbxgCIAIoCzIeLmxpdmVraXQucHJvdG8uQXVkaW9TdHJl", - "YW1JbmZvIp8BChBBdWRpb1N0cmVhbUV2ZW50EhUKDXN0cmVhbV9oYW5kbGUY", - "ASACKAQSOwoOZnJhbWVfcmVjZWl2ZWQYAiABKAsyIS5saXZla2l0LnByb3Rv", - "LkF1ZGlvRnJhbWVSZWNlaXZlZEgAEiwKA2VvcxgDIAEoCzIdLmxpdmVraXQu", - "cHJvdG8uQXVkaW9TdHJlYW1FT1NIAEIJCgdtZXNzYWdlIkkKEkF1ZGlvRnJh", - "bWVSZWNlaXZlZBIzCgVmcmFtZRgBIAIoCzIkLmxpdmVraXQucHJvdG8uT3du", - "ZWRBdWRpb0ZyYW1lQnVmZmVyIhAKDkF1ZGlvU3RyZWFtRU9TImUKEkF1ZGlv", - "U291cmNlT3B0aW9ucxIZChFlY2hvX2NhbmNlbGxhdGlvbhgBIAIoCBIZChFu", - "b2lzZV9zdXBwcmVzc2lvbhgCIAIoCBIZChFhdXRvX2dhaW5fY29udHJvbBgD", - "IAIoCCI/Cg9BdWRpb1NvdXJjZUluZm8SLAoEdHlwZRgCIAIoDjIeLmxpdmVr", - "aXQucHJvdG8uQXVkaW9Tb3VyY2VUeXBlIm8KEE93bmVkQXVkaW9Tb3VyY2US", - "LQoGaGFuZGxlGAEgAigLMh0ubGl2ZWtpdC5wcm90by5GZmlPd25lZEhhbmRs", - "ZRIsCgRpbmZvGAIgAigLMh4ubGl2ZWtpdC5wcm90by5BdWRpb1NvdXJjZUlu", - "Zm8iFAoSQXVkaW9SZXNhbXBsZXJJbmZvInUKE093bmVkQXVkaW9SZXNhbXBs", - "ZXISLQoGaGFuZGxlGAEgAigLMh0ubGl2ZWtpdC5wcm90by5GZmlPd25lZEhh", - "bmRsZRIvCgRpbmZvGAIgAigLMiEubGl2ZWtpdC5wcm90by5BdWRpb1Jlc2Ft", - "cGxlckluZm8iEgoQU294UmVzYW1wbGVySW5mbyJxChFPd25lZFNveFJlc2Ft", - "cGxlchItCgZoYW5kbGUYASACKAsyHS5saXZla2l0LnByb3RvLkZmaU93bmVk", - "SGFuZGxlEi0KBGluZm8YAiACKAsyHy5saXZla2l0LnByb3RvLlNveFJlc2Ft", - "cGxlckluZm8qSgoUU294UmVzYW1wbGVyRGF0YVR5cGUSGAoUU09YUl9EQVRB", - "VFlQRV9JTlQxNkkQABIYChRTT1hSX0RBVEFUWVBFX0lOVDE2UxABKosBChBT", - "b3hRdWFsaXR5UmVjaXBlEhYKElNPWFJfUVVBTElUWV9RVUlDSxAAEhQKEFNP", - "WFJfUVVBTElUWV9MT1cQARIXChNTT1hSX1FVQUxJVFlfTUVESVVNEAISFQoR", - "U09YUl9RVUFMSVRZX0hJR0gQAxIZChVTT1hSX1FVQUxJVFlfVkVSWUhJR0gQ", - "BCqXAQoLU294RmxhZ0JpdHMSFgoSU09YUl9ST0xMT0ZGX1NNQUxMEAASFwoT", - "U09YUl9ST0xMT0ZGX01FRElVTRABEhUKEVNPWFJfUk9MTE9GRl9OT05FEAIS", - "GAoUU09YUl9ISUdIX1BSRUNfQ0xPQ0sQAxIZChVTT1hSX0RPVUJMRV9QUkVD", - "SVNJT04QBBILCgdTT1hSX1ZSEAUqQQoPQXVkaW9TdHJlYW1UeXBlEhcKE0FV", - "RElPX1NUUkVBTV9OQVRJVkUQABIVChFBVURJT19TVFJFQU1fSFRNTBABKioK", - "D0F1ZGlvU291cmNlVHlwZRIXChNBVURJT19TT1VSQ0VfTkFUSVZFEABCEKoC", - "DUxpdmVLaXQuUHJvdG8=")); + "bnVtX2NoYW5uZWxzGAQgASgNEh4KFmF1ZGlvX2ZpbHRlcl9tb2R1bGVfaWQY", + "BSABKAkSHAoUYXVkaW9fZmlsdGVyX29wdGlvbnMYBiABKAkiSQoWTmV3QXVk", + "aW9TdHJlYW1SZXNwb25zZRIvCgZzdHJlYW0YASACKAsyHy5saXZla2l0LnBy", + "b3RvLk93bmVkQXVkaW9TdHJlYW0iiAIKIUF1ZGlvU3RyZWFtRnJvbVBhcnRp", + "Y2lwYW50UmVxdWVzdBIaChJwYXJ0aWNpcGFudF9oYW5kbGUYASACKAQSLAoE", + "dHlwZRgCIAIoDjIeLmxpdmVraXQucHJvdG8uQXVkaW9TdHJlYW1UeXBlEjAK", + "DHRyYWNrX3NvdXJjZRgDIAEoDjIaLmxpdmVraXQucHJvdG8uVHJhY2tTb3Vy", + "Y2USEwoLc2FtcGxlX3JhdGUYBSABKA0SFAoMbnVtX2NoYW5uZWxzGAYgASgN", + "Eh4KFmF1ZGlvX2ZpbHRlcl9tb2R1bGVfaWQYByABKAkSHAoUYXVkaW9fZmls", + "dGVyX29wdGlvbnMYCCABKAkiVQoiQXVkaW9TdHJlYW1Gcm9tUGFydGljaXBh", + "bnRSZXNwb25zZRIvCgZzdHJlYW0YASACKAsyHy5saXZla2l0LnByb3RvLk93", + "bmVkQXVkaW9TdHJlYW0iuwEKFU5ld0F1ZGlvU291cmNlUmVxdWVzdBIsCgR0", + "eXBlGAEgAigOMh4ubGl2ZWtpdC5wcm90by5BdWRpb1NvdXJjZVR5cGUSMgoH", + "b3B0aW9ucxgCIAEoCzIhLmxpdmVraXQucHJvdG8uQXVkaW9Tb3VyY2VPcHRp", + "b25zEhMKC3NhbXBsZV9yYXRlGAMgAigNEhQKDG51bV9jaGFubmVscxgEIAIo", + "DRIVCg1xdWV1ZV9zaXplX21zGAUgASgNIkkKFk5ld0F1ZGlvU291cmNlUmVz", + "cG9uc2USLwoGc291cmNlGAEgAigLMh8ubGl2ZWtpdC5wcm90by5Pd25lZEF1", + "ZGlvU291cmNlImYKGENhcHR1cmVBdWRpb0ZyYW1lUmVxdWVzdBIVCg1zb3Vy", + "Y2VfaGFuZGxlGAEgAigEEjMKBmJ1ZmZlchgCIAIoCzIjLmxpdmVraXQucHJv", + "dG8uQXVkaW9GcmFtZUJ1ZmZlckluZm8iLQoZQ2FwdHVyZUF1ZGlvRnJhbWVS", + "ZXNwb25zZRIQCghhc3luY19pZBgBIAIoBCI8ChlDYXB0dXJlQXVkaW9GcmFt", + "ZUNhbGxiYWNrEhAKCGFzeW5jX2lkGAEgAigEEg0KBWVycm9yGAIgASgJIjAK", + "F0NsZWFyQXVkaW9CdWZmZXJSZXF1ZXN0EhUKDXNvdXJjZV9oYW5kbGUYASAC", + "KAQiGgoYQ2xlYXJBdWRpb0J1ZmZlclJlc3BvbnNlIhoKGE5ld0F1ZGlvUmVz", + "YW1wbGVyUmVxdWVzdCJSChlOZXdBdWRpb1Jlc2FtcGxlclJlc3BvbnNlEjUK", + "CXJlc2FtcGxlchgBIAIoCzIiLmxpdmVraXQucHJvdG8uT3duZWRBdWRpb1Jl", + "c2FtcGxlciKTAQoXUmVtaXhBbmRSZXNhbXBsZVJlcXVlc3QSGAoQcmVzYW1w", + "bGVyX2hhbmRsZRgBIAIoBBIzCgZidWZmZXIYAiACKAsyIy5saXZla2l0LnBy", + "b3RvLkF1ZGlvRnJhbWVCdWZmZXJJbmZvEhQKDG51bV9jaGFubmVscxgDIAIo", + "DRITCgtzYW1wbGVfcmF0ZRgEIAIoDSJQChhSZW1peEFuZFJlc2FtcGxlUmVz", + "cG9uc2USNAoGYnVmZmVyGAEgAigLMiQubGl2ZWtpdC5wcm90by5Pd25lZEF1", + "ZGlvRnJhbWVCdWZmZXIilQEKDU5ld0FwbVJlcXVlc3QSHgoWZWNob19jYW5j", + "ZWxsZXJfZW5hYmxlZBgBIAIoCBIfChdnYWluX2NvbnRyb2xsZXJfZW5hYmxl", + "ZBgCIAIoCBIgChhoaWdoX3Bhc3NfZmlsdGVyX2VuYWJsZWQYAyACKAgSIQoZ", + "bm9pc2Vfc3VwcHJlc3Npb25fZW5hYmxlZBgEIAIoCCI2Cg5OZXdBcG1SZXNw", + "b25zZRIkCgNhcG0YASACKAsyFy5saXZla2l0LnByb3RvLk93bmVkQXBtIngK", + "F0FwbVByb2Nlc3NTdHJlYW1SZXF1ZXN0EhIKCmFwbV9oYW5kbGUYASACKAQS", + "EAoIZGF0YV9wdHIYAiACKAQSDAoEc2l6ZRgDIAIoDRITCgtzYW1wbGVfcmF0", + "ZRgEIAIoDRIUCgxudW1fY2hhbm5lbHMYBSACKA0iKQoYQXBtUHJvY2Vzc1N0", + "cmVhbVJlc3BvbnNlEg0KBWVycm9yGAEgASgJIn8KHkFwbVByb2Nlc3NSZXZl", + "cnNlU3RyZWFtUmVxdWVzdBISCgphcG1faGFuZGxlGAEgAigEEhAKCGRhdGFf", + "cHRyGAIgAigEEgwKBHNpemUYAyACKA0SEwoLc2FtcGxlX3JhdGUYBCACKA0S", + "FAoMbnVtX2NoYW5uZWxzGAUgAigNIjAKH0FwbVByb2Nlc3NSZXZlcnNlU3Ry", + "ZWFtUmVzcG9uc2USDQoFZXJyb3IYASABKAkiQAoYQXBtU2V0U3RyZWFtRGVs", + "YXlSZXF1ZXN0EhIKCmFwbV9oYW5kbGUYASACKAQSEAoIZGVsYXlfbXMYAiAC", + "KAUiKgoZQXBtU2V0U3RyZWFtRGVsYXlSZXNwb25zZRINCgVlcnJvchgBIAEo", + "CSKcAgoWTmV3U294UmVzYW1wbGVyUmVxdWVzdBISCgppbnB1dF9yYXRlGAEg", + "AigBEhMKC291dHB1dF9yYXRlGAIgAigBEhQKDG51bV9jaGFubmVscxgDIAIo", + "DRI8Cg9pbnB1dF9kYXRhX3R5cGUYBCACKA4yIy5saXZla2l0LnByb3RvLlNv", + "eFJlc2FtcGxlckRhdGFUeXBlEj0KEG91dHB1dF9kYXRhX3R5cGUYBSACKA4y", + "Iy5saXZla2l0LnByb3RvLlNveFJlc2FtcGxlckRhdGFUeXBlEjcKDnF1YWxp", + "dHlfcmVjaXBlGAYgAigOMh8ubGl2ZWtpdC5wcm90by5Tb3hRdWFsaXR5UmVj", + "aXBlEg0KBWZsYWdzGAcgASgNImwKF05ld1NveFJlc2FtcGxlclJlc3BvbnNl", + "EjUKCXJlc2FtcGxlchgBIAEoCzIgLmxpdmVraXQucHJvdG8uT3duZWRTb3hS", + "ZXNhbXBsZXJIABIPCgVlcnJvchgCIAEoCUgAQgkKB21lc3NhZ2UiUwoXUHVz", + "aFNveFJlc2FtcGxlclJlcXVlc3QSGAoQcmVzYW1wbGVyX2hhbmRsZRgBIAIo", + "BBIQCghkYXRhX3B0chgCIAIoBBIMCgRzaXplGAMgAigNIksKGFB1c2hTb3hS", + "ZXNhbXBsZXJSZXNwb25zZRISCgpvdXRwdXRfcHRyGAEgAigEEgwKBHNpemUY", + "AiACKA0SDQoFZXJyb3IYAyABKAkiNAoYRmx1c2hTb3hSZXNhbXBsZXJSZXF1", + "ZXN0EhgKEHJlc2FtcGxlcl9oYW5kbGUYASACKAQiTAoZRmx1c2hTb3hSZXNh", + "bXBsZXJSZXNwb25zZRISCgpvdXRwdXRfcHRyGAEgAigEEgwKBHNpemUYAiAC", + "KA0SDQoFZXJyb3IYAyABKAkicAoUQXVkaW9GcmFtZUJ1ZmZlckluZm8SEAoI", + "ZGF0YV9wdHIYASACKAQSFAoMbnVtX2NoYW5uZWxzGAIgAigNEhMKC3NhbXBs", + "ZV9yYXRlGAMgAigNEhsKE3NhbXBsZXNfcGVyX2NoYW5uZWwYBCACKA0ieQoV", + "T3duZWRBdWRpb0ZyYW1lQnVmZmVyEi0KBmhhbmRsZRgBIAIoCzIdLmxpdmVr", + "aXQucHJvdG8uRmZpT3duZWRIYW5kbGUSMQoEaW5mbxgCIAIoCzIjLmxpdmVr", + "aXQucHJvdG8uQXVkaW9GcmFtZUJ1ZmZlckluZm8iPwoPQXVkaW9TdHJlYW1J", + "bmZvEiwKBHR5cGUYASACKA4yHi5saXZla2l0LnByb3RvLkF1ZGlvU3RyZWFt", + "VHlwZSJvChBPd25lZEF1ZGlvU3RyZWFtEi0KBmhhbmRsZRgBIAIoCzIdLmxp", + "dmVraXQucHJvdG8uRmZpT3duZWRIYW5kbGUSLAoEaW5mbxgCIAIoCzIeLmxp", + "dmVraXQucHJvdG8uQXVkaW9TdHJlYW1JbmZvIp8BChBBdWRpb1N0cmVhbUV2", + "ZW50EhUKDXN0cmVhbV9oYW5kbGUYASACKAQSOwoOZnJhbWVfcmVjZWl2ZWQY", + "AiABKAsyIS5saXZla2l0LnByb3RvLkF1ZGlvRnJhbWVSZWNlaXZlZEgAEiwK", + "A2VvcxgDIAEoCzIdLmxpdmVraXQucHJvdG8uQXVkaW9TdHJlYW1FT1NIAEIJ", + "CgdtZXNzYWdlIkkKEkF1ZGlvRnJhbWVSZWNlaXZlZBIzCgVmcmFtZRgBIAIo", + "CzIkLmxpdmVraXQucHJvdG8uT3duZWRBdWRpb0ZyYW1lQnVmZmVyIhAKDkF1", + "ZGlvU3RyZWFtRU9TImUKEkF1ZGlvU291cmNlT3B0aW9ucxIZChFlY2hvX2Nh", + "bmNlbGxhdGlvbhgBIAIoCBIZChFub2lzZV9zdXBwcmVzc2lvbhgCIAIoCBIZ", + "ChFhdXRvX2dhaW5fY29udHJvbBgDIAIoCCI/Cg9BdWRpb1NvdXJjZUluZm8S", + "LAoEdHlwZRgCIAIoDjIeLmxpdmVraXQucHJvdG8uQXVkaW9Tb3VyY2VUeXBl", + "Im8KEE93bmVkQXVkaW9Tb3VyY2USLQoGaGFuZGxlGAEgAigLMh0ubGl2ZWtp", + "dC5wcm90by5GZmlPd25lZEhhbmRsZRIsCgRpbmZvGAIgAigLMh4ubGl2ZWtp", + "dC5wcm90by5BdWRpb1NvdXJjZUluZm8iFAoSQXVkaW9SZXNhbXBsZXJJbmZv", + "InUKE093bmVkQXVkaW9SZXNhbXBsZXISLQoGaGFuZGxlGAEgAigLMh0ubGl2", + "ZWtpdC5wcm90by5GZmlPd25lZEhhbmRsZRIvCgRpbmZvGAIgAigLMiEubGl2", + "ZWtpdC5wcm90by5BdWRpb1Jlc2FtcGxlckluZm8iOQoIT3duZWRBcG0SLQoG", + "aGFuZGxlGAEgAigLMh0ubGl2ZWtpdC5wcm90by5GZmlPd25lZEhhbmRsZSIS", + "ChBTb3hSZXNhbXBsZXJJbmZvInEKEU93bmVkU294UmVzYW1wbGVyEi0KBmhh", + "bmRsZRgBIAIoCzIdLmxpdmVraXQucHJvdG8uRmZpT3duZWRIYW5kbGUSLQoE", + "aW5mbxgCIAIoCzIfLmxpdmVraXQucHJvdG8uU294UmVzYW1wbGVySW5mbyJc", + "ChxMb2FkQXVkaW9GaWx0ZXJQbHVnaW5SZXF1ZXN0EhMKC3BsdWdpbl9wYXRo", + "GAEgAigJEhQKDGRlcGVuZGVuY2llcxgCIAMoCRIRCgltb2R1bGVfaWQYAyAC", + "KAkiLgodTG9hZEF1ZGlvRmlsdGVyUGx1Z2luUmVzcG9uc2USDQoFZXJyb3IY", + "ASABKAkqSgoUU294UmVzYW1wbGVyRGF0YVR5cGUSGAoUU09YUl9EQVRBVFlQ", + "RV9JTlQxNkkQABIYChRTT1hSX0RBVEFUWVBFX0lOVDE2UxABKosBChBTb3hR", + "dWFsaXR5UmVjaXBlEhYKElNPWFJfUVVBTElUWV9RVUlDSxAAEhQKEFNPWFJf", + "UVVBTElUWV9MT1cQARIXChNTT1hSX1FVQUxJVFlfTUVESVVNEAISFQoRU09Y", + "Ul9RVUFMSVRZX0hJR0gQAxIZChVTT1hSX1FVQUxJVFlfVkVSWUhJR0gQBCqX", + "AQoLU294RmxhZ0JpdHMSFgoSU09YUl9ST0xMT0ZGX1NNQUxMEAASFwoTU09Y", + "Ul9ST0xMT0ZGX01FRElVTRABEhUKEVNPWFJfUk9MTE9GRl9OT05FEAISGAoU", + "U09YUl9ISUdIX1BSRUNfQ0xPQ0sQAxIZChVTT1hSX0RPVUJMRV9QUkVDSVNJ", + "T04QBBILCgdTT1hSX1ZSEAUqQQoPQXVkaW9TdHJlYW1UeXBlEhcKE0FVRElP", + "X1NUUkVBTV9OQVRJVkUQABIVChFBVURJT19TVFJFQU1fSFRNTBABKioKD0F1", + "ZGlvU291cmNlVHlwZRIXChNBVURJT19TT1VSQ0VfTkFUSVZFEABCEKoCDUxp", + "dmVLaXQuUHJvdG8=")); descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData, new pbr::FileDescriptor[] { global::LiveKit.Proto.HandleReflection.Descriptor, global::LiveKit.Proto.TrackReflection.Descriptor, }, new pbr::GeneratedClrTypeInfo(new[] {typeof(global::LiveKit.Proto.SoxResamplerDataType), typeof(global::LiveKit.Proto.SoxQualityRecipe), typeof(global::LiveKit.Proto.SoxFlagBits), typeof(global::LiveKit.Proto.AudioStreamType), typeof(global::LiveKit.Proto.AudioSourceType), }, null, new pbr::GeneratedClrTypeInfo[] { - new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.NewAudioStreamRequest), global::LiveKit.Proto.NewAudioStreamRequest.Parser, new[]{ "TrackHandle", "Type", "SampleRate", "NumChannels" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.NewAudioStreamRequest), global::LiveKit.Proto.NewAudioStreamRequest.Parser, new[]{ "TrackHandle", "Type", "SampleRate", "NumChannels", "AudioFilterModuleId", "AudioFilterOptions" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.NewAudioStreamResponse), global::LiveKit.Proto.NewAudioStreamResponse.Parser, new[]{ "Stream" }, null, null, null, null), - new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.AudioStreamFromParticipantRequest), global::LiveKit.Proto.AudioStreamFromParticipantRequest.Parser, new[]{ "ParticipantHandle", "Type", "TrackSource", "SampleRate", "NumChannels" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.AudioStreamFromParticipantRequest), global::LiveKit.Proto.AudioStreamFromParticipantRequest.Parser, new[]{ "ParticipantHandle", "Type", "TrackSource", "SampleRate", "NumChannels", "AudioFilterModuleId", "AudioFilterOptions" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.AudioStreamFromParticipantResponse), global::LiveKit.Proto.AudioStreamFromParticipantResponse.Parser, new[]{ "Stream" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.NewAudioSourceRequest), global::LiveKit.Proto.NewAudioSourceRequest.Parser, new[]{ "Type", "Options", "SampleRate", "NumChannels", "QueueSizeMs" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.NewAudioSourceResponse), global::LiveKit.Proto.NewAudioSourceResponse.Parser, new[]{ "Source" }, null, null, null, null), @@ -129,6 +151,14 @@ static AudioFrameReflection() { new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.NewAudioResamplerResponse), global::LiveKit.Proto.NewAudioResamplerResponse.Parser, new[]{ "Resampler" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.RemixAndResampleRequest), global::LiveKit.Proto.RemixAndResampleRequest.Parser, new[]{ "ResamplerHandle", "Buffer", "NumChannels", "SampleRate" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.RemixAndResampleResponse), global::LiveKit.Proto.RemixAndResampleResponse.Parser, new[]{ "Buffer" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.NewApmRequest), global::LiveKit.Proto.NewApmRequest.Parser, new[]{ "EchoCancellerEnabled", "GainControllerEnabled", "HighPassFilterEnabled", "NoiseSuppressionEnabled" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.NewApmResponse), global::LiveKit.Proto.NewApmResponse.Parser, new[]{ "Apm" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.ApmProcessStreamRequest), global::LiveKit.Proto.ApmProcessStreamRequest.Parser, new[]{ "ApmHandle", "DataPtr", "Size", "SampleRate", "NumChannels" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.ApmProcessStreamResponse), global::LiveKit.Proto.ApmProcessStreamResponse.Parser, new[]{ "Error" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.ApmProcessReverseStreamRequest), global::LiveKit.Proto.ApmProcessReverseStreamRequest.Parser, new[]{ "ApmHandle", "DataPtr", "Size", "SampleRate", "NumChannels" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.ApmProcessReverseStreamResponse), global::LiveKit.Proto.ApmProcessReverseStreamResponse.Parser, new[]{ "Error" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.ApmSetStreamDelayRequest), global::LiveKit.Proto.ApmSetStreamDelayRequest.Parser, new[]{ "ApmHandle", "DelayMs" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.ApmSetStreamDelayResponse), global::LiveKit.Proto.ApmSetStreamDelayResponse.Parser, new[]{ "Error" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.NewSoxResamplerRequest), global::LiveKit.Proto.NewSoxResamplerRequest.Parser, new[]{ "InputRate", "OutputRate", "NumChannels", "InputDataType", "OutputDataType", "QualityRecipe", "Flags" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.NewSoxResamplerResponse), global::LiveKit.Proto.NewSoxResamplerResponse.Parser, new[]{ "Resampler", "Error" }, new[]{ "Message" }, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.PushSoxResamplerRequest), global::LiveKit.Proto.PushSoxResamplerRequest.Parser, new[]{ "ResamplerHandle", "DataPtr", "Size" }, null, null, null, null), @@ -147,8 +177,11 @@ static AudioFrameReflection() { new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.OwnedAudioSource), global::LiveKit.Proto.OwnedAudioSource.Parser, new[]{ "Handle", "Info" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.AudioResamplerInfo), global::LiveKit.Proto.AudioResamplerInfo.Parser, null, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.OwnedAudioResampler), global::LiveKit.Proto.OwnedAudioResampler.Parser, new[]{ "Handle", "Info" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.OwnedApm), global::LiveKit.Proto.OwnedApm.Parser, new[]{ "Handle" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.SoxResamplerInfo), global::LiveKit.Proto.SoxResamplerInfo.Parser, null, null, null, null, null), - new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.OwnedSoxResampler), global::LiveKit.Proto.OwnedSoxResampler.Parser, new[]{ "Handle", "Info" }, null, null, null, null) + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.OwnedSoxResampler), global::LiveKit.Proto.OwnedSoxResampler.Parser, new[]{ "Handle", "Info" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.LoadAudioFilterPluginRequest), global::LiveKit.Proto.LoadAudioFilterPluginRequest.Parser, new[]{ "PluginPath", "Dependencies", "ModuleId" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.LoadAudioFilterPluginResponse), global::LiveKit.Proto.LoadAudioFilterPluginResponse.Parser, new[]{ "Error" }, null, null, null, null) })); } #endregion @@ -255,6 +288,8 @@ public NewAudioStreamRequest(NewAudioStreamRequest other) : this() { type_ = other.type_; sampleRate_ = other.sampleRate_; numChannels_ = other.numChannels_; + audioFilterModuleId_ = other.audioFilterModuleId_; + audioFilterOptions_ = other.audioFilterOptions_; _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); } @@ -372,6 +407,61 @@ public void ClearNumChannels() { _hasBits0 &= ~8; } + /// Field number for the "audio_filter_module_id" field. + public const int AudioFilterModuleIdFieldNumber = 5; + private readonly static string AudioFilterModuleIdDefaultValue = ""; + + private string audioFilterModuleId_; + /// + /// Unique identifier passed in LoadAudioFilterPluginRequest + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string AudioFilterModuleId { + get { return audioFilterModuleId_ ?? AudioFilterModuleIdDefaultValue; } + set { + audioFilterModuleId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + /// Gets whether the "audio_filter_module_id" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasAudioFilterModuleId { + get { return audioFilterModuleId_ != null; } + } + /// Clears the value of the "audio_filter_module_id" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearAudioFilterModuleId() { + audioFilterModuleId_ = null; + } + + /// Field number for the "audio_filter_options" field. + public const int AudioFilterOptionsFieldNumber = 6; + private readonly static string AudioFilterOptionsDefaultValue = ""; + + private string audioFilterOptions_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string AudioFilterOptions { + get { return audioFilterOptions_ ?? AudioFilterOptionsDefaultValue; } + set { + audioFilterOptions_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + /// Gets whether the "audio_filter_options" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasAudioFilterOptions { + get { return audioFilterOptions_ != null; } + } + /// Clears the value of the "audio_filter_options" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearAudioFilterOptions() { + audioFilterOptions_ = null; + } + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override bool Equals(object other) { @@ -391,6 +481,8 @@ public bool Equals(NewAudioStreamRequest other) { if (Type != other.Type) return false; if (SampleRate != other.SampleRate) return false; if (NumChannels != other.NumChannels) return false; + if (AudioFilterModuleId != other.AudioFilterModuleId) return false; + if (AudioFilterOptions != other.AudioFilterOptions) return false; return Equals(_unknownFields, other._unknownFields); } @@ -402,6 +494,8 @@ public override int GetHashCode() { if (HasType) hash ^= Type.GetHashCode(); if (HasSampleRate) hash ^= SampleRate.GetHashCode(); if (HasNumChannels) hash ^= NumChannels.GetHashCode(); + if (HasAudioFilterModuleId) hash ^= AudioFilterModuleId.GetHashCode(); + if (HasAudioFilterOptions) hash ^= AudioFilterOptions.GetHashCode(); if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } @@ -436,6 +530,14 @@ public void WriteTo(pb::CodedOutputStream output) { output.WriteRawTag(32); output.WriteUInt32(NumChannels); } + if (HasAudioFilterModuleId) { + output.WriteRawTag(42); + output.WriteString(AudioFilterModuleId); + } + if (HasAudioFilterOptions) { + output.WriteRawTag(50); + output.WriteString(AudioFilterOptions); + } if (_unknownFields != null) { _unknownFields.WriteTo(output); } @@ -462,6 +564,14 @@ public void WriteTo(pb::CodedOutputStream output) { output.WriteRawTag(32); output.WriteUInt32(NumChannels); } + if (HasAudioFilterModuleId) { + output.WriteRawTag(42); + output.WriteString(AudioFilterModuleId); + } + if (HasAudioFilterOptions) { + output.WriteRawTag(50); + output.WriteString(AudioFilterOptions); + } if (_unknownFields != null) { _unknownFields.WriteTo(ref output); } @@ -484,6 +594,12 @@ public int CalculateSize() { if (HasNumChannels) { size += 1 + pb::CodedOutputStream.ComputeUInt32Size(NumChannels); } + if (HasAudioFilterModuleId) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(AudioFilterModuleId); + } + if (HasAudioFilterOptions) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(AudioFilterOptions); + } if (_unknownFields != null) { size += _unknownFields.CalculateSize(); } @@ -508,6 +624,12 @@ public void MergeFrom(NewAudioStreamRequest other) { if (other.HasNumChannels) { NumChannels = other.NumChannels; } + if (other.HasAudioFilterModuleId) { + AudioFilterModuleId = other.AudioFilterModuleId; + } + if (other.HasAudioFilterOptions) { + AudioFilterOptions = other.AudioFilterOptions; + } _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); } @@ -543,6 +665,14 @@ public void MergeFrom(pb::CodedInputStream input) { NumChannels = input.ReadUInt32(); break; } + case 42: { + AudioFilterModuleId = input.ReadString(); + break; + } + case 50: { + AudioFilterOptions = input.ReadString(); + break; + } } } #endif @@ -578,6 +708,14 @@ public void MergeFrom(pb::CodedInputStream input) { NumChannels = input.ReadUInt32(); break; } + case 42: { + AudioFilterModuleId = input.ReadString(); + break; + } + case 50: { + AudioFilterOptions = input.ReadString(); + break; + } } } } @@ -834,6 +972,8 @@ public AudioStreamFromParticipantRequest(AudioStreamFromParticipantRequest other trackSource_ = other.trackSource_; sampleRate_ = other.sampleRate_; numChannels_ = other.numChannels_; + audioFilterModuleId_ = other.audioFilterModuleId_; + audioFilterOptions_ = other.audioFilterOptions_; _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); } @@ -978,6 +1118,58 @@ public void ClearNumChannels() { _hasBits0 &= ~16; } + /// Field number for the "audio_filter_module_id" field. + public const int AudioFilterModuleIdFieldNumber = 7; + private readonly static string AudioFilterModuleIdDefaultValue = ""; + + private string audioFilterModuleId_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string AudioFilterModuleId { + get { return audioFilterModuleId_ ?? AudioFilterModuleIdDefaultValue; } + set { + audioFilterModuleId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + /// Gets whether the "audio_filter_module_id" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasAudioFilterModuleId { + get { return audioFilterModuleId_ != null; } + } + /// Clears the value of the "audio_filter_module_id" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearAudioFilterModuleId() { + audioFilterModuleId_ = null; + } + + /// Field number for the "audio_filter_options" field. + public const int AudioFilterOptionsFieldNumber = 8; + private readonly static string AudioFilterOptionsDefaultValue = ""; + + private string audioFilterOptions_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string AudioFilterOptions { + get { return audioFilterOptions_ ?? AudioFilterOptionsDefaultValue; } + set { + audioFilterOptions_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + /// Gets whether the "audio_filter_options" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasAudioFilterOptions { + get { return audioFilterOptions_ != null; } + } + /// Clears the value of the "audio_filter_options" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearAudioFilterOptions() { + audioFilterOptions_ = null; + } + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override bool Equals(object other) { @@ -998,6 +1190,8 @@ public bool Equals(AudioStreamFromParticipantRequest other) { if (TrackSource != other.TrackSource) return false; if (SampleRate != other.SampleRate) return false; if (NumChannels != other.NumChannels) return false; + if (AudioFilterModuleId != other.AudioFilterModuleId) return false; + if (AudioFilterOptions != other.AudioFilterOptions) return false; return Equals(_unknownFields, other._unknownFields); } @@ -1010,6 +1204,8 @@ public override int GetHashCode() { if (HasTrackSource) hash ^= TrackSource.GetHashCode(); if (HasSampleRate) hash ^= SampleRate.GetHashCode(); if (HasNumChannels) hash ^= NumChannels.GetHashCode(); + if (HasAudioFilterModuleId) hash ^= AudioFilterModuleId.GetHashCode(); + if (HasAudioFilterOptions) hash ^= AudioFilterOptions.GetHashCode(); if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } @@ -1048,6 +1244,14 @@ public void WriteTo(pb::CodedOutputStream output) { output.WriteRawTag(48); output.WriteUInt32(NumChannels); } + if (HasAudioFilterModuleId) { + output.WriteRawTag(58); + output.WriteString(AudioFilterModuleId); + } + if (HasAudioFilterOptions) { + output.WriteRawTag(66); + output.WriteString(AudioFilterOptions); + } if (_unknownFields != null) { _unknownFields.WriteTo(output); } @@ -1078,6 +1282,14 @@ public void WriteTo(pb::CodedOutputStream output) { output.WriteRawTag(48); output.WriteUInt32(NumChannels); } + if (HasAudioFilterModuleId) { + output.WriteRawTag(58); + output.WriteString(AudioFilterModuleId); + } + if (HasAudioFilterOptions) { + output.WriteRawTag(66); + output.WriteString(AudioFilterOptions); + } if (_unknownFields != null) { _unknownFields.WriteTo(ref output); } @@ -1103,6 +1315,12 @@ public int CalculateSize() { if (HasNumChannels) { size += 1 + pb::CodedOutputStream.ComputeUInt32Size(NumChannels); } + if (HasAudioFilterModuleId) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(AudioFilterModuleId); + } + if (HasAudioFilterOptions) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(AudioFilterOptions); + } if (_unknownFields != null) { size += _unknownFields.CalculateSize(); } @@ -1130,6 +1348,12 @@ public void MergeFrom(AudioStreamFromParticipantRequest other) { if (other.HasNumChannels) { NumChannels = other.NumChannels; } + if (other.HasAudioFilterModuleId) { + AudioFilterModuleId = other.AudioFilterModuleId; + } + if (other.HasAudioFilterOptions) { + AudioFilterOptions = other.AudioFilterOptions; + } _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); } @@ -1169,6 +1393,14 @@ public void MergeFrom(pb::CodedInputStream input) { NumChannels = input.ReadUInt32(); break; } + case 58: { + AudioFilterModuleId = input.ReadString(); + break; + } + case 66: { + AudioFilterOptions = input.ReadString(); + break; + } } } #endif @@ -1208,6 +1440,14 @@ public void MergeFrom(pb::CodedInputStream input) { NumChannels = input.ReadUInt32(); break; } + case 58: { + AudioFilterModuleId = input.ReadString(); + break; + } + case 66: { + AudioFilterOptions = input.ReadString(); + break; + } } } } @@ -4118,17 +4358,17 @@ public void MergeFrom(pb::CodedInputStream input) { } [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] - public sealed partial class NewSoxResamplerRequest : pb::IMessage + public sealed partial class NewApmRequest : pb::IMessage #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE , pb::IBufferMessage #endif { - private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new NewSoxResamplerRequest()); + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new NewApmRequest()); private pb::UnknownFieldSet _unknownFields; private int _hasBits0; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public static pb::MessageParser Parser { get { return _parser; } } + public static pb::MessageParser Parser { get { return _parser; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] @@ -4144,7 +4384,7 @@ public sealed partial class NewSoxResamplerRequest : pb::IMessageField number for the "input_rate" field. - public const int InputRateFieldNumber = 1; - private readonly static double InputRateDefaultValue = 0D; + /// Field number for the "echo_canceller_enabled" field. + public const int EchoCancellerEnabledFieldNumber = 1; + private readonly static bool EchoCancellerEnabledDefaultValue = false; - private double inputRate_; + private bool echoCancellerEnabled_; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public double InputRate { - get { if ((_hasBits0 & 1) != 0) { return inputRate_; } else { return InputRateDefaultValue; } } + public bool EchoCancellerEnabled { + get { if ((_hasBits0 & 1) != 0) { return echoCancellerEnabled_; } else { return EchoCancellerEnabledDefaultValue; } } set { _hasBits0 |= 1; - inputRate_ = value; + echoCancellerEnabled_ = value; } } - /// Gets whether the "input_rate" field is set + /// Gets whether the "echo_canceller_enabled" field is set [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool HasInputRate { + public bool HasEchoCancellerEnabled { get { return (_hasBits0 & 1) != 0; } } - /// Clears the value of the "input_rate" field + /// Clears the value of the "echo_canceller_enabled" field [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public void ClearInputRate() { + public void ClearEchoCancellerEnabled() { _hasBits0 &= ~1; } - /// Field number for the "output_rate" field. - public const int OutputRateFieldNumber = 2; - private readonly static double OutputRateDefaultValue = 0D; + /// Field number for the "gain_controller_enabled" field. + public const int GainControllerEnabledFieldNumber = 2; + private readonly static bool GainControllerEnabledDefaultValue = false; - private double outputRate_; + private bool gainControllerEnabled_; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public double OutputRate { - get { if ((_hasBits0 & 2) != 0) { return outputRate_; } else { return OutputRateDefaultValue; } } + public bool GainControllerEnabled { + get { if ((_hasBits0 & 2) != 0) { return gainControllerEnabled_; } else { return GainControllerEnabledDefaultValue; } } set { _hasBits0 |= 2; - outputRate_ = value; + gainControllerEnabled_ = value; } } - /// Gets whether the "output_rate" field is set + /// Gets whether the "gain_controller_enabled" field is set [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool HasOutputRate { + public bool HasGainControllerEnabled { get { return (_hasBits0 & 2) != 0; } } - /// Clears the value of the "output_rate" field + /// Clears the value of the "gain_controller_enabled" field [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public void ClearOutputRate() { + public void ClearGainControllerEnabled() { _hasBits0 &= ~2; } - /// Field number for the "num_channels" field. - public const int NumChannelsFieldNumber = 3; - private readonly static uint NumChannelsDefaultValue = 0; + /// Field number for the "high_pass_filter_enabled" field. + public const int HighPassFilterEnabledFieldNumber = 3; + private readonly static bool HighPassFilterEnabledDefaultValue = false; - private uint numChannels_; + private bool highPassFilterEnabled_; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public uint NumChannels { - get { if ((_hasBits0 & 4) != 0) { return numChannels_; } else { return NumChannelsDefaultValue; } } + public bool HighPassFilterEnabled { + get { if ((_hasBits0 & 4) != 0) { return highPassFilterEnabled_; } else { return HighPassFilterEnabledDefaultValue; } } set { _hasBits0 |= 4; - numChannels_ = value; + highPassFilterEnabled_ = value; } } - /// Gets whether the "num_channels" field is set + /// Gets whether the "high_pass_filter_enabled" field is set [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool HasNumChannels { + public bool HasHighPassFilterEnabled { get { return (_hasBits0 & 4) != 0; } } - /// Clears the value of the "num_channels" field + /// Clears the value of the "high_pass_filter_enabled" field [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public void ClearNumChannels() { + public void ClearHighPassFilterEnabled() { _hasBits0 &= ~4; } - /// Field number for the "input_data_type" field. - public const int InputDataTypeFieldNumber = 4; - private readonly static global::LiveKit.Proto.SoxResamplerDataType InputDataTypeDefaultValue = global::LiveKit.Proto.SoxResamplerDataType.SoxrDatatypeInt16I; + /// Field number for the "noise_suppression_enabled" field. + public const int NoiseSuppressionEnabledFieldNumber = 4; + private readonly static bool NoiseSuppressionEnabledDefaultValue = false; - private global::LiveKit.Proto.SoxResamplerDataType inputDataType_; + private bool noiseSuppressionEnabled_; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public global::LiveKit.Proto.SoxResamplerDataType InputDataType { - get { if ((_hasBits0 & 8) != 0) { return inputDataType_; } else { return InputDataTypeDefaultValue; } } + public bool NoiseSuppressionEnabled { + get { if ((_hasBits0 & 8) != 0) { return noiseSuppressionEnabled_; } else { return NoiseSuppressionEnabledDefaultValue; } } set { _hasBits0 |= 8; - inputDataType_ = value; + noiseSuppressionEnabled_ = value; } } - /// Gets whether the "input_data_type" field is set + /// Gets whether the "noise_suppression_enabled" field is set [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool HasInputDataType { + public bool HasNoiseSuppressionEnabled { get { return (_hasBits0 & 8) != 0; } } - /// Clears the value of the "input_data_type" field + /// Clears the value of the "noise_suppression_enabled" field [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public void ClearInputDataType() { + public void ClearNoiseSuppressionEnabled() { _hasBits0 &= ~8; } - /// Field number for the "output_data_type" field. - public const int OutputDataTypeFieldNumber = 5; - private readonly static global::LiveKit.Proto.SoxResamplerDataType OutputDataTypeDefaultValue = global::LiveKit.Proto.SoxResamplerDataType.SoxrDatatypeInt16I; - - private global::LiveKit.Proto.SoxResamplerDataType outputDataType_; - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public global::LiveKit.Proto.SoxResamplerDataType OutputDataType { - get { if ((_hasBits0 & 16) != 0) { return outputDataType_; } else { return OutputDataTypeDefaultValue; } } - set { - _hasBits0 |= 16; - outputDataType_ = value; - } - } - /// Gets whether the "output_data_type" field is set - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool HasOutputDataType { - get { return (_hasBits0 & 16) != 0; } - } - /// Clears the value of the "output_data_type" field - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public void ClearOutputDataType() { - _hasBits0 &= ~16; - } - - /// Field number for the "quality_recipe" field. - public const int QualityRecipeFieldNumber = 6; - private readonly static global::LiveKit.Proto.SoxQualityRecipe QualityRecipeDefaultValue = global::LiveKit.Proto.SoxQualityRecipe.SoxrQualityQuick; - - private global::LiveKit.Proto.SoxQualityRecipe qualityRecipe_; - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public global::LiveKit.Proto.SoxQualityRecipe QualityRecipe { - get { if ((_hasBits0 & 32) != 0) { return qualityRecipe_; } else { return QualityRecipeDefaultValue; } } - set { - _hasBits0 |= 32; - qualityRecipe_ = value; - } - } - /// Gets whether the "quality_recipe" field is set - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool HasQualityRecipe { - get { return (_hasBits0 & 32) != 0; } - } - /// Clears the value of the "quality_recipe" field - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public void ClearQualityRecipe() { - _hasBits0 &= ~32; - } - - /// Field number for the "flags" field. - public const int FlagsFieldNumber = 7; - private readonly static uint FlagsDefaultValue = 0; - - private uint flags_; - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public uint Flags { - get { if ((_hasBits0 & 64) != 0) { return flags_; } else { return FlagsDefaultValue; } } - set { - _hasBits0 |= 64; - flags_ = value; - } - } - /// Gets whether the "flags" field is set - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool HasFlags { - get { return (_hasBits0 & 64) != 0; } - } - /// Clears the value of the "flags" field - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public void ClearFlags() { - _hasBits0 &= ~64; - } - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override bool Equals(object other) { - return Equals(other as NewSoxResamplerRequest); + return Equals(other as NewApmRequest); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool Equals(NewSoxResamplerRequest other) { + public bool Equals(NewApmRequest other) { if (ReferenceEquals(other, null)) { return false; } if (ReferenceEquals(other, this)) { return true; } - if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(InputRate, other.InputRate)) return false; - if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(OutputRate, other.OutputRate)) return false; - if (NumChannels != other.NumChannels) return false; - if (InputDataType != other.InputDataType) return false; - if (OutputDataType != other.OutputDataType) return false; - if (QualityRecipe != other.QualityRecipe) return false; - if (Flags != other.Flags) return false; + if (EchoCancellerEnabled != other.EchoCancellerEnabled) return false; + if (GainControllerEnabled != other.GainControllerEnabled) return false; + if (HighPassFilterEnabled != other.HighPassFilterEnabled) return false; + if (NoiseSuppressionEnabled != other.NoiseSuppressionEnabled) return false; return Equals(_unknownFields, other._unknownFields); } @@ -4388,13 +4541,10 @@ public bool Equals(NewSoxResamplerRequest other) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override int GetHashCode() { int hash = 1; - if (HasInputRate) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(InputRate); - if (HasOutputRate) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(OutputRate); - if (HasNumChannels) hash ^= NumChannels.GetHashCode(); - if (HasInputDataType) hash ^= InputDataType.GetHashCode(); - if (HasOutputDataType) hash ^= OutputDataType.GetHashCode(); - if (HasQualityRecipe) hash ^= QualityRecipe.GetHashCode(); - if (HasFlags) hash ^= Flags.GetHashCode(); + if (HasEchoCancellerEnabled) hash ^= EchoCancellerEnabled.GetHashCode(); + if (HasGainControllerEnabled) hash ^= GainControllerEnabled.GetHashCode(); + if (HasHighPassFilterEnabled) hash ^= HighPassFilterEnabled.GetHashCode(); + if (HasNoiseSuppressionEnabled) hash ^= NoiseSuppressionEnabled.GetHashCode(); if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } @@ -4413,33 +4563,21 @@ public void WriteTo(pb::CodedOutputStream output) { #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE output.WriteRawMessage(this); #else - if (HasInputRate) { - output.WriteRawTag(9); - output.WriteDouble(InputRate); + if (HasEchoCancellerEnabled) { + output.WriteRawTag(8); + output.WriteBool(EchoCancellerEnabled); } - if (HasOutputRate) { - output.WriteRawTag(17); - output.WriteDouble(OutputRate); + if (HasGainControllerEnabled) { + output.WriteRawTag(16); + output.WriteBool(GainControllerEnabled); } - if (HasNumChannels) { + if (HasHighPassFilterEnabled) { output.WriteRawTag(24); - output.WriteUInt32(NumChannels); + output.WriteBool(HighPassFilterEnabled); } - if (HasInputDataType) { + if (HasNoiseSuppressionEnabled) { output.WriteRawTag(32); - output.WriteEnum((int) InputDataType); - } - if (HasOutputDataType) { - output.WriteRawTag(40); - output.WriteEnum((int) OutputDataType); - } - if (HasQualityRecipe) { - output.WriteRawTag(48); - output.WriteEnum((int) QualityRecipe); - } - if (HasFlags) { - output.WriteRawTag(56); - output.WriteUInt32(Flags); + output.WriteBool(NoiseSuppressionEnabled); } if (_unknownFields != null) { _unknownFields.WriteTo(output); @@ -4451,33 +4589,21 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { - if (HasInputRate) { - output.WriteRawTag(9); - output.WriteDouble(InputRate); + if (HasEchoCancellerEnabled) { + output.WriteRawTag(8); + output.WriteBool(EchoCancellerEnabled); } - if (HasOutputRate) { - output.WriteRawTag(17); - output.WriteDouble(OutputRate); + if (HasGainControllerEnabled) { + output.WriteRawTag(16); + output.WriteBool(GainControllerEnabled); } - if (HasNumChannels) { + if (HasHighPassFilterEnabled) { output.WriteRawTag(24); - output.WriteUInt32(NumChannels); + output.WriteBool(HighPassFilterEnabled); } - if (HasInputDataType) { + if (HasNoiseSuppressionEnabled) { output.WriteRawTag(32); - output.WriteEnum((int) InputDataType); - } - if (HasOutputDataType) { - output.WriteRawTag(40); - output.WriteEnum((int) OutputDataType); - } - if (HasQualityRecipe) { - output.WriteRawTag(48); - output.WriteEnum((int) QualityRecipe); - } - if (HasFlags) { - output.WriteRawTag(56); - output.WriteUInt32(Flags); + output.WriteBool(NoiseSuppressionEnabled); } if (_unknownFields != null) { _unknownFields.WriteTo(ref output); @@ -4489,26 +4615,17 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public int CalculateSize() { int size = 0; - if (HasInputRate) { - size += 1 + 8; - } - if (HasOutputRate) { - size += 1 + 8; - } - if (HasNumChannels) { - size += 1 + pb::CodedOutputStream.ComputeUInt32Size(NumChannels); - } - if (HasInputDataType) { - size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) InputDataType); + if (HasEchoCancellerEnabled) { + size += 1 + 1; } - if (HasOutputDataType) { - size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) OutputDataType); + if (HasGainControllerEnabled) { + size += 1 + 1; } - if (HasQualityRecipe) { - size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) QualityRecipe); + if (HasHighPassFilterEnabled) { + size += 1 + 1; } - if (HasFlags) { - size += 1 + pb::CodedOutputStream.ComputeUInt32Size(Flags); + if (HasNoiseSuppressionEnabled) { + size += 1 + 1; } if (_unknownFields != null) { size += _unknownFields.CalculateSize(); @@ -4518,30 +4635,21 @@ public int CalculateSize() { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public void MergeFrom(NewSoxResamplerRequest other) { + public void MergeFrom(NewApmRequest other) { if (other == null) { return; } - if (other.HasInputRate) { - InputRate = other.InputRate; - } - if (other.HasOutputRate) { - OutputRate = other.OutputRate; - } - if (other.HasNumChannels) { - NumChannels = other.NumChannels; - } - if (other.HasInputDataType) { - InputDataType = other.InputDataType; + if (other.HasEchoCancellerEnabled) { + EchoCancellerEnabled = other.EchoCancellerEnabled; } - if (other.HasOutputDataType) { - OutputDataType = other.OutputDataType; + if (other.HasGainControllerEnabled) { + GainControllerEnabled = other.GainControllerEnabled; } - if (other.HasQualityRecipe) { - QualityRecipe = other.QualityRecipe; + if (other.HasHighPassFilterEnabled) { + HighPassFilterEnabled = other.HighPassFilterEnabled; } - if (other.HasFlags) { - Flags = other.Flags; + if (other.HasNoiseSuppressionEnabled) { + NoiseSuppressionEnabled = other.NoiseSuppressionEnabled; } _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); } @@ -4562,32 +4670,20 @@ public void MergeFrom(pb::CodedInputStream input) { default: _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); break; - case 9: { - InputRate = input.ReadDouble(); + case 8: { + EchoCancellerEnabled = input.ReadBool(); break; } - case 17: { - OutputRate = input.ReadDouble(); + case 16: { + GainControllerEnabled = input.ReadBool(); break; } case 24: { - NumChannels = input.ReadUInt32(); + HighPassFilterEnabled = input.ReadBool(); break; } case 32: { - InputDataType = (global::LiveKit.Proto.SoxResamplerDataType) input.ReadEnum(); - break; - } - case 40: { - OutputDataType = (global::LiveKit.Proto.SoxResamplerDataType) input.ReadEnum(); - break; - } - case 48: { - QualityRecipe = (global::LiveKit.Proto.SoxQualityRecipe) input.ReadEnum(); - break; - } - case 56: { - Flags = input.ReadUInt32(); + NoiseSuppressionEnabled = input.ReadBool(); break; } } @@ -4609,32 +4705,20 @@ public void MergeFrom(pb::CodedInputStream input) { default: _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); break; - case 9: { - InputRate = input.ReadDouble(); + case 8: { + EchoCancellerEnabled = input.ReadBool(); break; } - case 17: { - OutputRate = input.ReadDouble(); + case 16: { + GainControllerEnabled = input.ReadBool(); break; } case 24: { - NumChannels = input.ReadUInt32(); + HighPassFilterEnabled = input.ReadBool(); break; } case 32: { - InputDataType = (global::LiveKit.Proto.SoxResamplerDataType) input.ReadEnum(); - break; - } - case 40: { - OutputDataType = (global::LiveKit.Proto.SoxResamplerDataType) input.ReadEnum(); - break; - } - case 48: { - QualityRecipe = (global::LiveKit.Proto.SoxQualityRecipe) input.ReadEnum(); - break; - } - case 56: { - Flags = input.ReadUInt32(); + NoiseSuppressionEnabled = input.ReadBool(); break; } } @@ -4645,16 +4729,16 @@ public void MergeFrom(pb::CodedInputStream input) { } [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] - public sealed partial class NewSoxResamplerResponse : pb::IMessage + public sealed partial class NewApmResponse : pb::IMessage #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE , pb::IBufferMessage #endif { - private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new NewSoxResamplerResponse()); + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new NewApmResponse()); private pb::UnknownFieldSet _unknownFields; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public static pb::MessageParser Parser { get { return _parser; } } + public static pb::MessageParser Parser { get { return _parser; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] @@ -4670,7 +4754,7 @@ public sealed partial class NewSoxResamplerResponse : pb::IMessageField number for the "resampler" field. - public const int ResamplerFieldNumber = 1; - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public global::LiveKit.Proto.OwnedSoxResampler Resampler { - get { return messageCase_ == MessageOneofCase.Resampler ? (global::LiveKit.Proto.OwnedSoxResampler) message_ : null; } - set { - message_ = value; - messageCase_ = value == null ? MessageOneofCase.None : MessageOneofCase.Resampler; - } + public NewApmResponse Clone() { + return new NewApmResponse(this); } - /// Field number for the "error" field. - public const int ErrorFieldNumber = 2; + /// Field number for the "apm" field. + public const int ApmFieldNumber = 1; + private global::LiveKit.Proto.OwnedApm apm_; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public string Error { - get { return HasError ? (string) message_ : ""; } + public global::LiveKit.Proto.OwnedApm Apm { + get { return apm_; } set { - message_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); - messageCase_ = MessageOneofCase.Error; - } - } - /// Gets whether the "error" field is set - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool HasError { - get { return messageCase_ == MessageOneofCase.Error; } - } - /// Clears the value of the oneof if it's currently set to "error" - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public void ClearError() { - if (HasError) { - ClearMessage(); + apm_ = value; } } - private object message_; - /// Enum of possible cases for the "message" oneof. - public enum MessageOneofCase { - None = 0, - Resampler = 1, - Error = 2, - } - private MessageOneofCase messageCase_ = MessageOneofCase.None; - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public MessageOneofCase MessageCase { - get { return messageCase_; } - } - - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public void ClearMessage() { - messageCase_ = MessageOneofCase.None; - message_ = null; - } - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override bool Equals(object other) { - return Equals(other as NewSoxResamplerResponse); + return Equals(other as NewApmResponse); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool Equals(NewSoxResamplerResponse other) { + public bool Equals(NewApmResponse other) { if (ReferenceEquals(other, null)) { return false; } if (ReferenceEquals(other, this)) { return true; } - if (!object.Equals(Resampler, other.Resampler)) return false; - if (Error != other.Error) return false; - if (MessageCase != other.MessageCase) return false; + if (!object.Equals(Apm, other.Apm)) return false; return Equals(_unknownFields, other._unknownFields); } @@ -4781,9 +4808,7 @@ public bool Equals(NewSoxResamplerResponse other) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override int GetHashCode() { int hash = 1; - if (messageCase_ == MessageOneofCase.Resampler) hash ^= Resampler.GetHashCode(); - if (HasError) hash ^= Error.GetHashCode(); - hash ^= (int) messageCase_; + if (apm_ != null) hash ^= Apm.GetHashCode(); if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } @@ -4802,13 +4827,9 @@ public void WriteTo(pb::CodedOutputStream output) { #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE output.WriteRawMessage(this); #else - if (messageCase_ == MessageOneofCase.Resampler) { + if (apm_ != null) { output.WriteRawTag(10); - output.WriteMessage(Resampler); - } - if (HasError) { - output.WriteRawTag(18); - output.WriteString(Error); + output.WriteMessage(Apm); } if (_unknownFields != null) { _unknownFields.WriteTo(output); @@ -4820,13 +4841,9 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { - if (messageCase_ == MessageOneofCase.Resampler) { + if (apm_ != null) { output.WriteRawTag(10); - output.WriteMessage(Resampler); - } - if (HasError) { - output.WriteRawTag(18); - output.WriteString(Error); + output.WriteMessage(Apm); } if (_unknownFields != null) { _unknownFields.WriteTo(ref output); @@ -4838,11 +4855,8 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public int CalculateSize() { int size = 0; - if (messageCase_ == MessageOneofCase.Resampler) { - size += 1 + pb::CodedOutputStream.ComputeMessageSize(Resampler); - } - if (HasError) { - size += 1 + pb::CodedOutputStream.ComputeStringSize(Error); + if (apm_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Apm); } if (_unknownFields != null) { size += _unknownFields.CalculateSize(); @@ -4852,22 +4866,16 @@ public int CalculateSize() { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public void MergeFrom(NewSoxResamplerResponse other) { + public void MergeFrom(NewApmResponse other) { if (other == null) { return; } - switch (other.MessageCase) { - case MessageOneofCase.Resampler: - if (Resampler == null) { - Resampler = new global::LiveKit.Proto.OwnedSoxResampler(); - } - Resampler.MergeFrom(other.Resampler); - break; - case MessageOneofCase.Error: - Error = other.Error; - break; + if (other.apm_ != null) { + if (apm_ == null) { + Apm = new global::LiveKit.Proto.OwnedApm(); + } + Apm.MergeFrom(other.Apm); } - _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); } @@ -4888,16 +4896,10 @@ public void MergeFrom(pb::CodedInputStream input) { _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); break; case 10: { - global::LiveKit.Proto.OwnedSoxResampler subBuilder = new global::LiveKit.Proto.OwnedSoxResampler(); - if (messageCase_ == MessageOneofCase.Resampler) { - subBuilder.MergeFrom(Resampler); + if (apm_ == null) { + Apm = new global::LiveKit.Proto.OwnedApm(); } - input.ReadMessage(subBuilder); - Resampler = subBuilder; - break; - } - case 18: { - Error = input.ReadString(); + input.ReadMessage(Apm); break; } } @@ -4920,16 +4922,10 @@ public void MergeFrom(pb::CodedInputStream input) { _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); break; case 10: { - global::LiveKit.Proto.OwnedSoxResampler subBuilder = new global::LiveKit.Proto.OwnedSoxResampler(); - if (messageCase_ == MessageOneofCase.Resampler) { - subBuilder.MergeFrom(Resampler); + if (apm_ == null) { + Apm = new global::LiveKit.Proto.OwnedApm(); } - input.ReadMessage(subBuilder); - Resampler = subBuilder; - break; - } - case 18: { - Error = input.ReadString(); + input.ReadMessage(Apm); break; } } @@ -4940,17 +4936,17 @@ public void MergeFrom(pb::CodedInputStream input) { } [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] - public sealed partial class PushSoxResamplerRequest : pb::IMessage + public sealed partial class ApmProcessStreamRequest : pb::IMessage #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE , pb::IBufferMessage #endif { - private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new PushSoxResamplerRequest()); + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ApmProcessStreamRequest()); private pb::UnknownFieldSet _unknownFields; private int _hasBits0; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public static pb::MessageParser Parser { get { return _parser; } } + public static pb::MessageParser Parser { get { return _parser; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] @@ -4966,7 +4962,7 @@ public sealed partial class PushSoxResamplerRequest : pb::IMessageField number for the "resampler_handle" field. - public const int ResamplerHandleFieldNumber = 1; - private readonly static ulong ResamplerHandleDefaultValue = 0UL; + /// Field number for the "apm_handle" field. + public const int ApmHandleFieldNumber = 1; + private readonly static ulong ApmHandleDefaultValue = 0UL; - private ulong resamplerHandle_; + private ulong apmHandle_; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public ulong ResamplerHandle { - get { if ((_hasBits0 & 1) != 0) { return resamplerHandle_; } else { return ResamplerHandleDefaultValue; } } + public ulong ApmHandle { + get { if ((_hasBits0 & 1) != 0) { return apmHandle_; } else { return ApmHandleDefaultValue; } } set { _hasBits0 |= 1; - resamplerHandle_ = value; + apmHandle_ = value; } } - /// Gets whether the "resampler_handle" field is set + /// Gets whether the "apm_handle" field is set [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool HasResamplerHandle { + public bool HasApmHandle { get { return (_hasBits0 & 1) != 0; } } - /// Clears the value of the "resampler_handle" field + /// Clears the value of the "apm_handle" field [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public void ClearResamplerHandle() { + public void ClearApmHandle() { _hasBits0 &= ~1; } @@ -5021,7 +5019,7 @@ public void ClearResamplerHandle() { private ulong dataPtr_; /// - /// *const i16 + /// *mut i16 /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] @@ -5075,24 +5073,80 @@ public void ClearSize() { _hasBits0 &= ~4; } + /// Field number for the "sample_rate" field. + public const int SampleRateFieldNumber = 4; + private readonly static uint SampleRateDefaultValue = 0; + + private uint sampleRate_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public uint SampleRate { + get { if ((_hasBits0 & 8) != 0) { return sampleRate_; } else { return SampleRateDefaultValue; } } + set { + _hasBits0 |= 8; + sampleRate_ = value; + } + } + /// Gets whether the "sample_rate" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasSampleRate { + get { return (_hasBits0 & 8) != 0; } + } + /// Clears the value of the "sample_rate" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearSampleRate() { + _hasBits0 &= ~8; + } + + /// Field number for the "num_channels" field. + public const int NumChannelsFieldNumber = 5; + private readonly static uint NumChannelsDefaultValue = 0; + + private uint numChannels_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public uint NumChannels { + get { if ((_hasBits0 & 16) != 0) { return numChannels_; } else { return NumChannelsDefaultValue; } } + set { + _hasBits0 |= 16; + numChannels_ = value; + } + } + /// Gets whether the "num_channels" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasNumChannels { + get { return (_hasBits0 & 16) != 0; } + } + /// Clears the value of the "num_channels" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearNumChannels() { + _hasBits0 &= ~16; + } + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override bool Equals(object other) { - return Equals(other as PushSoxResamplerRequest); + return Equals(other as ApmProcessStreamRequest); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool Equals(PushSoxResamplerRequest other) { + public bool Equals(ApmProcessStreamRequest other) { if (ReferenceEquals(other, null)) { return false; } if (ReferenceEquals(other, this)) { return true; } - if (ResamplerHandle != other.ResamplerHandle) return false; + if (ApmHandle != other.ApmHandle) return false; if (DataPtr != other.DataPtr) return false; if (Size != other.Size) return false; + if (SampleRate != other.SampleRate) return false; + if (NumChannels != other.NumChannels) return false; return Equals(_unknownFields, other._unknownFields); } @@ -5100,9 +5154,11 @@ public bool Equals(PushSoxResamplerRequest other) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override int GetHashCode() { int hash = 1; - if (HasResamplerHandle) hash ^= ResamplerHandle.GetHashCode(); + if (HasApmHandle) hash ^= ApmHandle.GetHashCode(); if (HasDataPtr) hash ^= DataPtr.GetHashCode(); if (HasSize) hash ^= Size.GetHashCode(); + if (HasSampleRate) hash ^= SampleRate.GetHashCode(); + if (HasNumChannels) hash ^= NumChannels.GetHashCode(); if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } @@ -5121,9 +5177,9 @@ public void WriteTo(pb::CodedOutputStream output) { #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE output.WriteRawMessage(this); #else - if (HasResamplerHandle) { + if (HasApmHandle) { output.WriteRawTag(8); - output.WriteUInt64(ResamplerHandle); + output.WriteUInt64(ApmHandle); } if (HasDataPtr) { output.WriteRawTag(16); @@ -5133,6 +5189,14 @@ public void WriteTo(pb::CodedOutputStream output) { output.WriteRawTag(24); output.WriteUInt32(Size); } + if (HasSampleRate) { + output.WriteRawTag(32); + output.WriteUInt32(SampleRate); + } + if (HasNumChannels) { + output.WriteRawTag(40); + output.WriteUInt32(NumChannels); + } if (_unknownFields != null) { _unknownFields.WriteTo(output); } @@ -5143,9 +5207,9 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { - if (HasResamplerHandle) { + if (HasApmHandle) { output.WriteRawTag(8); - output.WriteUInt64(ResamplerHandle); + output.WriteUInt64(ApmHandle); } if (HasDataPtr) { output.WriteRawTag(16); @@ -5155,6 +5219,14 @@ public void WriteTo(pb::CodedOutputStream output) { output.WriteRawTag(24); output.WriteUInt32(Size); } + if (HasSampleRate) { + output.WriteRawTag(32); + output.WriteUInt32(SampleRate); + } + if (HasNumChannels) { + output.WriteRawTag(40); + output.WriteUInt32(NumChannels); + } if (_unknownFields != null) { _unknownFields.WriteTo(ref output); } @@ -5165,8 +5237,8 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public int CalculateSize() { int size = 0; - if (HasResamplerHandle) { - size += 1 + pb::CodedOutputStream.ComputeUInt64Size(ResamplerHandle); + if (HasApmHandle) { + size += 1 + pb::CodedOutputStream.ComputeUInt64Size(ApmHandle); } if (HasDataPtr) { size += 1 + pb::CodedOutputStream.ComputeUInt64Size(DataPtr); @@ -5174,6 +5246,12 @@ public int CalculateSize() { if (HasSize) { size += 1 + pb::CodedOutputStream.ComputeUInt32Size(Size); } + if (HasSampleRate) { + size += 1 + pb::CodedOutputStream.ComputeUInt32Size(SampleRate); + } + if (HasNumChannels) { + size += 1 + pb::CodedOutputStream.ComputeUInt32Size(NumChannels); + } if (_unknownFields != null) { size += _unknownFields.CalculateSize(); } @@ -5182,12 +5260,12 @@ public int CalculateSize() { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public void MergeFrom(PushSoxResamplerRequest other) { + public void MergeFrom(ApmProcessStreamRequest other) { if (other == null) { return; } - if (other.HasResamplerHandle) { - ResamplerHandle = other.ResamplerHandle; + if (other.HasApmHandle) { + ApmHandle = other.ApmHandle; } if (other.HasDataPtr) { DataPtr = other.DataPtr; @@ -5195,6 +5273,12 @@ public void MergeFrom(PushSoxResamplerRequest other) { if (other.HasSize) { Size = other.Size; } + if (other.HasSampleRate) { + SampleRate = other.SampleRate; + } + if (other.HasNumChannels) { + NumChannels = other.NumChannels; + } _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); } @@ -5215,7 +5299,7 @@ public void MergeFrom(pb::CodedInputStream input) { _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); break; case 8: { - ResamplerHandle = input.ReadUInt64(); + ApmHandle = input.ReadUInt64(); break; } case 16: { @@ -5226,6 +5310,14 @@ public void MergeFrom(pb::CodedInputStream input) { Size = input.ReadUInt32(); break; } + case 32: { + SampleRate = input.ReadUInt32(); + break; + } + case 40: { + NumChannels = input.ReadUInt32(); + break; + } } } #endif @@ -5246,7 +5338,7 @@ public void MergeFrom(pb::CodedInputStream input) { _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); break; case 8: { - ResamplerHandle = input.ReadUInt64(); + ApmHandle = input.ReadUInt64(); break; } case 16: { @@ -5257,6 +5349,14 @@ public void MergeFrom(pb::CodedInputStream input) { Size = input.ReadUInt32(); break; } + case 32: { + SampleRate = input.ReadUInt32(); + break; + } + case 40: { + NumChannels = input.ReadUInt32(); + break; + } } } } @@ -5265,17 +5365,16 @@ public void MergeFrom(pb::CodedInputStream input) { } [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] - public sealed partial class PushSoxResamplerResponse : pb::IMessage + public sealed partial class ApmProcessStreamResponse : pb::IMessage #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE , pb::IBufferMessage #endif { - private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new PushSoxResamplerResponse()); + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ApmProcessStreamResponse()); private pb::UnknownFieldSet _unknownFields; - private int _hasBits0; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public static pb::MessageParser Parser { get { return _parser; } } + public static pb::MessageParser Parser { get { return _parser; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] @@ -5291,7 +5390,7 @@ public sealed partial class PushSoxResamplerResponse : pb::IMessageField number for the "output_ptr" field. - public const int OutputPtrFieldNumber = 1; - private readonly static ulong OutputPtrDefaultValue = 0UL; - - private ulong outputPtr_; - /// - /// *const i16 (could be null) - /// - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public ulong OutputPtr { - get { if ((_hasBits0 & 1) != 0) { return outputPtr_; } else { return OutputPtrDefaultValue; } } - set { - _hasBits0 |= 1; - outputPtr_ = value; - } - } - /// Gets whether the "output_ptr" field is set - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool HasOutputPtr { - get { return (_hasBits0 & 1) != 0; } - } - /// Clears the value of the "output_ptr" field - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public void ClearOutputPtr() { - _hasBits0 &= ~1; - } - - /// Field number for the "size" field. - public const int SizeFieldNumber = 2; - private readonly static uint SizeDefaultValue = 0; - - private uint size_; - /// - /// in bytes - /// - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public uint Size { - get { if ((_hasBits0 & 2) != 0) { return size_; } else { return SizeDefaultValue; } } - set { - _hasBits0 |= 2; - size_ = value; - } - } - /// Gets whether the "size" field is set - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool HasSize { - get { return (_hasBits0 & 2) != 0; } - } - /// Clears the value of the "size" field - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public void ClearSize() { - _hasBits0 &= ~2; + public ApmProcessStreamResponse Clone() { + return new ApmProcessStreamResponse(this); } /// Field number for the "error" field. - public const int ErrorFieldNumber = 3; + public const int ErrorFieldNumber = 1; private readonly static string ErrorDefaultValue = ""; private string error_; @@ -5402,20 +5438,18 @@ public void ClearError() { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override bool Equals(object other) { - return Equals(other as PushSoxResamplerResponse); + return Equals(other as ApmProcessStreamResponse); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool Equals(PushSoxResamplerResponse other) { + public bool Equals(ApmProcessStreamResponse other) { if (ReferenceEquals(other, null)) { return false; } if (ReferenceEquals(other, this)) { return true; } - if (OutputPtr != other.OutputPtr) return false; - if (Size != other.Size) return false; if (Error != other.Error) return false; return Equals(_unknownFields, other._unknownFields); } @@ -5424,8 +5458,6 @@ public bool Equals(PushSoxResamplerResponse other) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override int GetHashCode() { int hash = 1; - if (HasOutputPtr) hash ^= OutputPtr.GetHashCode(); - if (HasSize) hash ^= Size.GetHashCode(); if (HasError) hash ^= Error.GetHashCode(); if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); @@ -5445,16 +5477,8 @@ public void WriteTo(pb::CodedOutputStream output) { #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE output.WriteRawMessage(this); #else - if (HasOutputPtr) { - output.WriteRawTag(8); - output.WriteUInt64(OutputPtr); - } - if (HasSize) { - output.WriteRawTag(16); - output.WriteUInt32(Size); - } if (HasError) { - output.WriteRawTag(26); + output.WriteRawTag(10); output.WriteString(Error); } if (_unknownFields != null) { @@ -5467,16 +5491,8 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { - if (HasOutputPtr) { - output.WriteRawTag(8); - output.WriteUInt64(OutputPtr); - } - if (HasSize) { - output.WriteRawTag(16); - output.WriteUInt32(Size); - } if (HasError) { - output.WriteRawTag(26); + output.WriteRawTag(10); output.WriteString(Error); } if (_unknownFields != null) { @@ -5489,12 +5505,6 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public int CalculateSize() { int size = 0; - if (HasOutputPtr) { - size += 1 + pb::CodedOutputStream.ComputeUInt64Size(OutputPtr); - } - if (HasSize) { - size += 1 + pb::CodedOutputStream.ComputeUInt32Size(Size); - } if (HasError) { size += 1 + pb::CodedOutputStream.ComputeStringSize(Error); } @@ -5506,16 +5516,10 @@ public int CalculateSize() { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public void MergeFrom(PushSoxResamplerResponse other) { + public void MergeFrom(ApmProcessStreamResponse other) { if (other == null) { return; } - if (other.HasOutputPtr) { - OutputPtr = other.OutputPtr; - } - if (other.HasSize) { - Size = other.Size; - } if (other.HasError) { Error = other.Error; } @@ -5538,15 +5542,7 @@ public void MergeFrom(pb::CodedInputStream input) { default: _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); break; - case 8: { - OutputPtr = input.ReadUInt64(); - break; - } - case 16: { - Size = input.ReadUInt32(); - break; - } - case 26: { + case 10: { Error = input.ReadString(); break; } @@ -5569,15 +5565,7 @@ public void MergeFrom(pb::CodedInputStream input) { default: _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); break; - case 8: { - OutputPtr = input.ReadUInt64(); - break; - } - case 16: { - Size = input.ReadUInt32(); - break; - } - case 26: { + case 10: { Error = input.ReadString(); break; } @@ -5589,17 +5577,17 @@ public void MergeFrom(pb::CodedInputStream input) { } [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] - public sealed partial class FlushSoxResamplerRequest : pb::IMessage + public sealed partial class ApmProcessReverseStreamRequest : pb::IMessage #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE , pb::IBufferMessage #endif { - private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new FlushSoxResamplerRequest()); + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ApmProcessReverseStreamRequest()); private pb::UnknownFieldSet _unknownFields; private int _hasBits0; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public static pb::MessageParser Parser { get { return _parser; } } + public static pb::MessageParser Parser { get { return _parser; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] @@ -5615,7 +5603,7 @@ public sealed partial class FlushSoxResamplerRequest : pb::IMessageField number for the "resampler_handle" field. - public const int ResamplerHandleFieldNumber = 1; - private readonly static ulong ResamplerHandleDefaultValue = 0UL; + /// Field number for the "apm_handle" field. + public const int ApmHandleFieldNumber = 1; + private readonly static ulong ApmHandleDefaultValue = 0UL; - private ulong resamplerHandle_; + private ulong apmHandle_; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public ulong ResamplerHandle { - get { if ((_hasBits0 & 1) != 0) { return resamplerHandle_; } else { return ResamplerHandleDefaultValue; } } + public ulong ApmHandle { + get { if ((_hasBits0 & 1) != 0) { return apmHandle_; } else { return ApmHandleDefaultValue; } } set { _hasBits0 |= 1; - resamplerHandle_ = value; + apmHandle_ = value; } } - /// Gets whether the "resampler_handle" field is set + /// Gets whether the "apm_handle" field is set [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool HasResamplerHandle { + public bool HasApmHandle { get { return (_hasBits0 & 1) != 0; } } - /// Clears the value of the "resampler_handle" field + /// Clears the value of the "apm_handle" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearApmHandle() { + _hasBits0 &= ~1; + } + + /// Field number for the "data_ptr" field. + public const int DataPtrFieldNumber = 2; + private readonly static ulong DataPtrDefaultValue = 0UL; + + private ulong dataPtr_; + /// + /// *mut i16 + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ulong DataPtr { + get { if ((_hasBits0 & 2) != 0) { return dataPtr_; } else { return DataPtrDefaultValue; } } + set { + _hasBits0 |= 2; + dataPtr_ = value; + } + } + /// Gets whether the "data_ptr" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasDataPtr { + get { return (_hasBits0 & 2) != 0; } + } + /// Clears the value of the "data_ptr" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearDataPtr() { + _hasBits0 &= ~2; + } + + /// Field number for the "size" field. + public const int SizeFieldNumber = 3; + private readonly static uint SizeDefaultValue = 0; + + private uint size_; + /// + /// in bytes + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public uint Size { + get { if ((_hasBits0 & 4) != 0) { return size_; } else { return SizeDefaultValue; } } + set { + _hasBits0 |= 4; + size_ = value; + } + } + /// Gets whether the "size" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasSize { + get { return (_hasBits0 & 4) != 0; } + } + /// Clears the value of the "size" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearSize() { + _hasBits0 &= ~4; + } + + /// Field number for the "sample_rate" field. + public const int SampleRateFieldNumber = 4; + private readonly static uint SampleRateDefaultValue = 0; + + private uint sampleRate_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public uint SampleRate { + get { if ((_hasBits0 & 8) != 0) { return sampleRate_; } else { return SampleRateDefaultValue; } } + set { + _hasBits0 |= 8; + sampleRate_ = value; + } + } + /// Gets whether the "sample_rate" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasSampleRate { + get { return (_hasBits0 & 8) != 0; } + } + /// Clears the value of the "sample_rate" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearSampleRate() { + _hasBits0 &= ~8; + } + + /// Field number for the "num_channels" field. + public const int NumChannelsFieldNumber = 5; + private readonly static uint NumChannelsDefaultValue = 0; + + private uint numChannels_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public uint NumChannels { + get { if ((_hasBits0 & 16) != 0) { return numChannels_; } else { return NumChannelsDefaultValue; } } + set { + _hasBits0 |= 16; + numChannels_ = value; + } + } + /// Gets whether the "num_channels" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasNumChannels { + get { return (_hasBits0 & 16) != 0; } + } + /// Clears the value of the "num_channels" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearNumChannels() { + _hasBits0 &= ~16; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as ApmProcessReverseStreamRequest); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(ApmProcessReverseStreamRequest other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (ApmHandle != other.ApmHandle) return false; + if (DataPtr != other.DataPtr) return false; + if (Size != other.Size) return false; + if (SampleRate != other.SampleRate) return false; + if (NumChannels != other.NumChannels) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (HasApmHandle) hash ^= ApmHandle.GetHashCode(); + if (HasDataPtr) hash ^= DataPtr.GetHashCode(); + if (HasSize) hash ^= Size.GetHashCode(); + if (HasSampleRate) hash ^= SampleRate.GetHashCode(); + if (HasNumChannels) hash ^= NumChannels.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (HasApmHandle) { + output.WriteRawTag(8); + output.WriteUInt64(ApmHandle); + } + if (HasDataPtr) { + output.WriteRawTag(16); + output.WriteUInt64(DataPtr); + } + if (HasSize) { + output.WriteRawTag(24); + output.WriteUInt32(Size); + } + if (HasSampleRate) { + output.WriteRawTag(32); + output.WriteUInt32(SampleRate); + } + if (HasNumChannels) { + output.WriteRawTag(40); + output.WriteUInt32(NumChannels); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (HasApmHandle) { + output.WriteRawTag(8); + output.WriteUInt64(ApmHandle); + } + if (HasDataPtr) { + output.WriteRawTag(16); + output.WriteUInt64(DataPtr); + } + if (HasSize) { + output.WriteRawTag(24); + output.WriteUInt32(Size); + } + if (HasSampleRate) { + output.WriteRawTag(32); + output.WriteUInt32(SampleRate); + } + if (HasNumChannels) { + output.WriteRawTag(40); + output.WriteUInt32(NumChannels); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (HasApmHandle) { + size += 1 + pb::CodedOutputStream.ComputeUInt64Size(ApmHandle); + } + if (HasDataPtr) { + size += 1 + pb::CodedOutputStream.ComputeUInt64Size(DataPtr); + } + if (HasSize) { + size += 1 + pb::CodedOutputStream.ComputeUInt32Size(Size); + } + if (HasSampleRate) { + size += 1 + pb::CodedOutputStream.ComputeUInt32Size(SampleRate); + } + if (HasNumChannels) { + size += 1 + pb::CodedOutputStream.ComputeUInt32Size(NumChannels); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(ApmProcessReverseStreamRequest other) { + if (other == null) { + return; + } + if (other.HasApmHandle) { + ApmHandle = other.ApmHandle; + } + if (other.HasDataPtr) { + DataPtr = other.DataPtr; + } + if (other.HasSize) { + Size = other.Size; + } + if (other.HasSampleRate) { + SampleRate = other.SampleRate; + } + if (other.HasNumChannels) { + NumChannels = other.NumChannels; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + ApmHandle = input.ReadUInt64(); + break; + } + case 16: { + DataPtr = input.ReadUInt64(); + break; + } + case 24: { + Size = input.ReadUInt32(); + break; + } + case 32: { + SampleRate = input.ReadUInt32(); + break; + } + case 40: { + NumChannels = input.ReadUInt32(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + ApmHandle = input.ReadUInt64(); + break; + } + case 16: { + DataPtr = input.ReadUInt64(); + break; + } + case 24: { + Size = input.ReadUInt32(); + break; + } + case 32: { + SampleRate = input.ReadUInt32(); + break; + } + case 40: { + NumChannels = input.ReadUInt32(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class ApmProcessReverseStreamResponse : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ApmProcessReverseStreamResponse()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.AudioFrameReflection.Descriptor.MessageTypes[20]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ApmProcessReverseStreamResponse() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ApmProcessReverseStreamResponse(ApmProcessReverseStreamResponse other) : this() { + error_ = other.error_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ApmProcessReverseStreamResponse Clone() { + return new ApmProcessReverseStreamResponse(this); + } + + /// Field number for the "error" field. + public const int ErrorFieldNumber = 1; + private readonly static string ErrorDefaultValue = ""; + + private string error_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Error { + get { return error_ ?? ErrorDefaultValue; } + set { + error_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + /// Gets whether the "error" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasError { + get { return error_ != null; } + } + /// Clears the value of the "error" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearError() { + error_ = null; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as ApmProcessReverseStreamResponse); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(ApmProcessReverseStreamResponse other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Error != other.Error) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (HasError) hash ^= Error.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (HasError) { + output.WriteRawTag(10); + output.WriteString(Error); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (HasError) { + output.WriteRawTag(10); + output.WriteString(Error); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (HasError) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Error); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(ApmProcessReverseStreamResponse other) { + if (other == null) { + return; + } + if (other.HasError) { + Error = other.Error; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + Error = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + Error = input.ReadString(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class ApmSetStreamDelayRequest : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ApmSetStreamDelayRequest()); + private pb::UnknownFieldSet _unknownFields; + private int _hasBits0; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.AudioFrameReflection.Descriptor.MessageTypes[21]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ApmSetStreamDelayRequest() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ApmSetStreamDelayRequest(ApmSetStreamDelayRequest other) : this() { + _hasBits0 = other._hasBits0; + apmHandle_ = other.apmHandle_; + delayMs_ = other.delayMs_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ApmSetStreamDelayRequest Clone() { + return new ApmSetStreamDelayRequest(this); + } + + /// Field number for the "apm_handle" field. + public const int ApmHandleFieldNumber = 1; + private readonly static ulong ApmHandleDefaultValue = 0UL; + + private ulong apmHandle_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ulong ApmHandle { + get { if ((_hasBits0 & 1) != 0) { return apmHandle_; } else { return ApmHandleDefaultValue; } } + set { + _hasBits0 |= 1; + apmHandle_ = value; + } + } + /// Gets whether the "apm_handle" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasApmHandle { + get { return (_hasBits0 & 1) != 0; } + } + /// Clears the value of the "apm_handle" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearApmHandle() { + _hasBits0 &= ~1; + } + + /// Field number for the "delay_ms" field. + public const int DelayMsFieldNumber = 2; + private readonly static int DelayMsDefaultValue = 0; + + private int delayMs_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int DelayMs { + get { if ((_hasBits0 & 2) != 0) { return delayMs_; } else { return DelayMsDefaultValue; } } + set { + _hasBits0 |= 2; + delayMs_ = value; + } + } + /// Gets whether the "delay_ms" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasDelayMs { + get { return (_hasBits0 & 2) != 0; } + } + /// Clears the value of the "delay_ms" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearDelayMs() { + _hasBits0 &= ~2; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as ApmSetStreamDelayRequest); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(ApmSetStreamDelayRequest other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (ApmHandle != other.ApmHandle) return false; + if (DelayMs != other.DelayMs) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (HasApmHandle) hash ^= ApmHandle.GetHashCode(); + if (HasDelayMs) hash ^= DelayMs.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (HasApmHandle) { + output.WriteRawTag(8); + output.WriteUInt64(ApmHandle); + } + if (HasDelayMs) { + output.WriteRawTag(16); + output.WriteInt32(DelayMs); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (HasApmHandle) { + output.WriteRawTag(8); + output.WriteUInt64(ApmHandle); + } + if (HasDelayMs) { + output.WriteRawTag(16); + output.WriteInt32(DelayMs); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (HasApmHandle) { + size += 1 + pb::CodedOutputStream.ComputeUInt64Size(ApmHandle); + } + if (HasDelayMs) { + size += 1 + pb::CodedOutputStream.ComputeInt32Size(DelayMs); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(ApmSetStreamDelayRequest other) { + if (other == null) { + return; + } + if (other.HasApmHandle) { + ApmHandle = other.ApmHandle; + } + if (other.HasDelayMs) { + DelayMs = other.DelayMs; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + ApmHandle = input.ReadUInt64(); + break; + } + case 16: { + DelayMs = input.ReadInt32(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + ApmHandle = input.ReadUInt64(); + break; + } + case 16: { + DelayMs = input.ReadInt32(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class ApmSetStreamDelayResponse : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ApmSetStreamDelayResponse()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.AudioFrameReflection.Descriptor.MessageTypes[22]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ApmSetStreamDelayResponse() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ApmSetStreamDelayResponse(ApmSetStreamDelayResponse other) : this() { + error_ = other.error_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ApmSetStreamDelayResponse Clone() { + return new ApmSetStreamDelayResponse(this); + } + + /// Field number for the "error" field. + public const int ErrorFieldNumber = 1; + private readonly static string ErrorDefaultValue = ""; + + private string error_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Error { + get { return error_ ?? ErrorDefaultValue; } + set { + error_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + /// Gets whether the "error" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasError { + get { return error_ != null; } + } + /// Clears the value of the "error" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearError() { + error_ = null; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as ApmSetStreamDelayResponse); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(ApmSetStreamDelayResponse other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Error != other.Error) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (HasError) hash ^= Error.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (HasError) { + output.WriteRawTag(10); + output.WriteString(Error); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (HasError) { + output.WriteRawTag(10); + output.WriteString(Error); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (HasError) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Error); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(ApmSetStreamDelayResponse other) { + if (other == null) { + return; + } + if (other.HasError) { + Error = other.Error; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + Error = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + Error = input.ReadString(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class NewSoxResamplerRequest : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new NewSoxResamplerRequest()); + private pb::UnknownFieldSet _unknownFields; + private int _hasBits0; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.AudioFrameReflection.Descriptor.MessageTypes[23]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public NewSoxResamplerRequest() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public NewSoxResamplerRequest(NewSoxResamplerRequest other) : this() { + _hasBits0 = other._hasBits0; + inputRate_ = other.inputRate_; + outputRate_ = other.outputRate_; + numChannels_ = other.numChannels_; + inputDataType_ = other.inputDataType_; + outputDataType_ = other.outputDataType_; + qualityRecipe_ = other.qualityRecipe_; + flags_ = other.flags_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public NewSoxResamplerRequest Clone() { + return new NewSoxResamplerRequest(this); + } + + /// Field number for the "input_rate" field. + public const int InputRateFieldNumber = 1; + private readonly static double InputRateDefaultValue = 0D; + + private double inputRate_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public double InputRate { + get { if ((_hasBits0 & 1) != 0) { return inputRate_; } else { return InputRateDefaultValue; } } + set { + _hasBits0 |= 1; + inputRate_ = value; + } + } + /// Gets whether the "input_rate" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasInputRate { + get { return (_hasBits0 & 1) != 0; } + } + /// Clears the value of the "input_rate" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearInputRate() { + _hasBits0 &= ~1; + } + + /// Field number for the "output_rate" field. + public const int OutputRateFieldNumber = 2; + private readonly static double OutputRateDefaultValue = 0D; + + private double outputRate_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public double OutputRate { + get { if ((_hasBits0 & 2) != 0) { return outputRate_; } else { return OutputRateDefaultValue; } } + set { + _hasBits0 |= 2; + outputRate_ = value; + } + } + /// Gets whether the "output_rate" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasOutputRate { + get { return (_hasBits0 & 2) != 0; } + } + /// Clears the value of the "output_rate" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearOutputRate() { + _hasBits0 &= ~2; + } + + /// Field number for the "num_channels" field. + public const int NumChannelsFieldNumber = 3; + private readonly static uint NumChannelsDefaultValue = 0; + + private uint numChannels_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public uint NumChannels { + get { if ((_hasBits0 & 4) != 0) { return numChannels_; } else { return NumChannelsDefaultValue; } } + set { + _hasBits0 |= 4; + numChannels_ = value; + } + } + /// Gets whether the "num_channels" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasNumChannels { + get { return (_hasBits0 & 4) != 0; } + } + /// Clears the value of the "num_channels" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearNumChannels() { + _hasBits0 &= ~4; + } + + /// Field number for the "input_data_type" field. + public const int InputDataTypeFieldNumber = 4; + private readonly static global::LiveKit.Proto.SoxResamplerDataType InputDataTypeDefaultValue = global::LiveKit.Proto.SoxResamplerDataType.SoxrDatatypeInt16I; + + private global::LiveKit.Proto.SoxResamplerDataType inputDataType_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.SoxResamplerDataType InputDataType { + get { if ((_hasBits0 & 8) != 0) { return inputDataType_; } else { return InputDataTypeDefaultValue; } } + set { + _hasBits0 |= 8; + inputDataType_ = value; + } + } + /// Gets whether the "input_data_type" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasInputDataType { + get { return (_hasBits0 & 8) != 0; } + } + /// Clears the value of the "input_data_type" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearInputDataType() { + _hasBits0 &= ~8; + } + + /// Field number for the "output_data_type" field. + public const int OutputDataTypeFieldNumber = 5; + private readonly static global::LiveKit.Proto.SoxResamplerDataType OutputDataTypeDefaultValue = global::LiveKit.Proto.SoxResamplerDataType.SoxrDatatypeInt16I; + + private global::LiveKit.Proto.SoxResamplerDataType outputDataType_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.SoxResamplerDataType OutputDataType { + get { if ((_hasBits0 & 16) != 0) { return outputDataType_; } else { return OutputDataTypeDefaultValue; } } + set { + _hasBits0 |= 16; + outputDataType_ = value; + } + } + /// Gets whether the "output_data_type" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasOutputDataType { + get { return (_hasBits0 & 16) != 0; } + } + /// Clears the value of the "output_data_type" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearOutputDataType() { + _hasBits0 &= ~16; + } + + /// Field number for the "quality_recipe" field. + public const int QualityRecipeFieldNumber = 6; + private readonly static global::LiveKit.Proto.SoxQualityRecipe QualityRecipeDefaultValue = global::LiveKit.Proto.SoxQualityRecipe.SoxrQualityQuick; + + private global::LiveKit.Proto.SoxQualityRecipe qualityRecipe_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.SoxQualityRecipe QualityRecipe { + get { if ((_hasBits0 & 32) != 0) { return qualityRecipe_; } else { return QualityRecipeDefaultValue; } } + set { + _hasBits0 |= 32; + qualityRecipe_ = value; + } + } + /// Gets whether the "quality_recipe" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasQualityRecipe { + get { return (_hasBits0 & 32) != 0; } + } + /// Clears the value of the "quality_recipe" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearQualityRecipe() { + _hasBits0 &= ~32; + } + + /// Field number for the "flags" field. + public const int FlagsFieldNumber = 7; + private readonly static uint FlagsDefaultValue = 0; + + private uint flags_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public uint Flags { + get { if ((_hasBits0 & 64) != 0) { return flags_; } else { return FlagsDefaultValue; } } + set { + _hasBits0 |= 64; + flags_ = value; + } + } + /// Gets whether the "flags" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasFlags { + get { return (_hasBits0 & 64) != 0; } + } + /// Clears the value of the "flags" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearFlags() { + _hasBits0 &= ~64; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as NewSoxResamplerRequest); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(NewSoxResamplerRequest other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(InputRate, other.InputRate)) return false; + if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(OutputRate, other.OutputRate)) return false; + if (NumChannels != other.NumChannels) return false; + if (InputDataType != other.InputDataType) return false; + if (OutputDataType != other.OutputDataType) return false; + if (QualityRecipe != other.QualityRecipe) return false; + if (Flags != other.Flags) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (HasInputRate) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(InputRate); + if (HasOutputRate) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(OutputRate); + if (HasNumChannels) hash ^= NumChannels.GetHashCode(); + if (HasInputDataType) hash ^= InputDataType.GetHashCode(); + if (HasOutputDataType) hash ^= OutputDataType.GetHashCode(); + if (HasQualityRecipe) hash ^= QualityRecipe.GetHashCode(); + if (HasFlags) hash ^= Flags.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (HasInputRate) { + output.WriteRawTag(9); + output.WriteDouble(InputRate); + } + if (HasOutputRate) { + output.WriteRawTag(17); + output.WriteDouble(OutputRate); + } + if (HasNumChannels) { + output.WriteRawTag(24); + output.WriteUInt32(NumChannels); + } + if (HasInputDataType) { + output.WriteRawTag(32); + output.WriteEnum((int) InputDataType); + } + if (HasOutputDataType) { + output.WriteRawTag(40); + output.WriteEnum((int) OutputDataType); + } + if (HasQualityRecipe) { + output.WriteRawTag(48); + output.WriteEnum((int) QualityRecipe); + } + if (HasFlags) { + output.WriteRawTag(56); + output.WriteUInt32(Flags); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (HasInputRate) { + output.WriteRawTag(9); + output.WriteDouble(InputRate); + } + if (HasOutputRate) { + output.WriteRawTag(17); + output.WriteDouble(OutputRate); + } + if (HasNumChannels) { + output.WriteRawTag(24); + output.WriteUInt32(NumChannels); + } + if (HasInputDataType) { + output.WriteRawTag(32); + output.WriteEnum((int) InputDataType); + } + if (HasOutputDataType) { + output.WriteRawTag(40); + output.WriteEnum((int) OutputDataType); + } + if (HasQualityRecipe) { + output.WriteRawTag(48); + output.WriteEnum((int) QualityRecipe); + } + if (HasFlags) { + output.WriteRawTag(56); + output.WriteUInt32(Flags); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (HasInputRate) { + size += 1 + 8; + } + if (HasOutputRate) { + size += 1 + 8; + } + if (HasNumChannels) { + size += 1 + pb::CodedOutputStream.ComputeUInt32Size(NumChannels); + } + if (HasInputDataType) { + size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) InputDataType); + } + if (HasOutputDataType) { + size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) OutputDataType); + } + if (HasQualityRecipe) { + size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) QualityRecipe); + } + if (HasFlags) { + size += 1 + pb::CodedOutputStream.ComputeUInt32Size(Flags); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(NewSoxResamplerRequest other) { + if (other == null) { + return; + } + if (other.HasInputRate) { + InputRate = other.InputRate; + } + if (other.HasOutputRate) { + OutputRate = other.OutputRate; + } + if (other.HasNumChannels) { + NumChannels = other.NumChannels; + } + if (other.HasInputDataType) { + InputDataType = other.InputDataType; + } + if (other.HasOutputDataType) { + OutputDataType = other.OutputDataType; + } + if (other.HasQualityRecipe) { + QualityRecipe = other.QualityRecipe; + } + if (other.HasFlags) { + Flags = other.Flags; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 9: { + InputRate = input.ReadDouble(); + break; + } + case 17: { + OutputRate = input.ReadDouble(); + break; + } + case 24: { + NumChannels = input.ReadUInt32(); + break; + } + case 32: { + InputDataType = (global::LiveKit.Proto.SoxResamplerDataType) input.ReadEnum(); + break; + } + case 40: { + OutputDataType = (global::LiveKit.Proto.SoxResamplerDataType) input.ReadEnum(); + break; + } + case 48: { + QualityRecipe = (global::LiveKit.Proto.SoxQualityRecipe) input.ReadEnum(); + break; + } + case 56: { + Flags = input.ReadUInt32(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 9: { + InputRate = input.ReadDouble(); + break; + } + case 17: { + OutputRate = input.ReadDouble(); + break; + } + case 24: { + NumChannels = input.ReadUInt32(); + break; + } + case 32: { + InputDataType = (global::LiveKit.Proto.SoxResamplerDataType) input.ReadEnum(); + break; + } + case 40: { + OutputDataType = (global::LiveKit.Proto.SoxResamplerDataType) input.ReadEnum(); + break; + } + case 48: { + QualityRecipe = (global::LiveKit.Proto.SoxQualityRecipe) input.ReadEnum(); + break; + } + case 56: { + Flags = input.ReadUInt32(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class NewSoxResamplerResponse : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new NewSoxResamplerResponse()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.AudioFrameReflection.Descriptor.MessageTypes[24]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public NewSoxResamplerResponse() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public NewSoxResamplerResponse(NewSoxResamplerResponse other) : this() { + switch (other.MessageCase) { + case MessageOneofCase.Resampler: + Resampler = other.Resampler.Clone(); + break; + case MessageOneofCase.Error: + Error = other.Error; + break; + } + + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public NewSoxResamplerResponse Clone() { + return new NewSoxResamplerResponse(this); + } + + /// Field number for the "resampler" field. + public const int ResamplerFieldNumber = 1; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.OwnedSoxResampler Resampler { + get { return messageCase_ == MessageOneofCase.Resampler ? (global::LiveKit.Proto.OwnedSoxResampler) message_ : null; } + set { + message_ = value; + messageCase_ = value == null ? MessageOneofCase.None : MessageOneofCase.Resampler; + } + } + + /// Field number for the "error" field. + public const int ErrorFieldNumber = 2; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Error { + get { return HasError ? (string) message_ : ""; } + set { + message_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + messageCase_ = MessageOneofCase.Error; + } + } + /// Gets whether the "error" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasError { + get { return messageCase_ == MessageOneofCase.Error; } + } + /// Clears the value of the oneof if it's currently set to "error" + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearError() { + if (HasError) { + ClearMessage(); + } + } + + private object message_; + /// Enum of possible cases for the "message" oneof. + public enum MessageOneofCase { + None = 0, + Resampler = 1, + Error = 2, + } + private MessageOneofCase messageCase_ = MessageOneofCase.None; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public MessageOneofCase MessageCase { + get { return messageCase_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearMessage() { + messageCase_ = MessageOneofCase.None; + message_ = null; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as NewSoxResamplerResponse); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(NewSoxResamplerResponse other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (!object.Equals(Resampler, other.Resampler)) return false; + if (Error != other.Error) return false; + if (MessageCase != other.MessageCase) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (messageCase_ == MessageOneofCase.Resampler) hash ^= Resampler.GetHashCode(); + if (HasError) hash ^= Error.GetHashCode(); + hash ^= (int) messageCase_; + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (messageCase_ == MessageOneofCase.Resampler) { + output.WriteRawTag(10); + output.WriteMessage(Resampler); + } + if (HasError) { + output.WriteRawTag(18); + output.WriteString(Error); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (messageCase_ == MessageOneofCase.Resampler) { + output.WriteRawTag(10); + output.WriteMessage(Resampler); + } + if (HasError) { + output.WriteRawTag(18); + output.WriteString(Error); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (messageCase_ == MessageOneofCase.Resampler) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Resampler); + } + if (HasError) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Error); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(NewSoxResamplerResponse other) { + if (other == null) { + return; + } + switch (other.MessageCase) { + case MessageOneofCase.Resampler: + if (Resampler == null) { + Resampler = new global::LiveKit.Proto.OwnedSoxResampler(); + } + Resampler.MergeFrom(other.Resampler); + break; + case MessageOneofCase.Error: + Error = other.Error; + break; + } + + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + global::LiveKit.Proto.OwnedSoxResampler subBuilder = new global::LiveKit.Proto.OwnedSoxResampler(); + if (messageCase_ == MessageOneofCase.Resampler) { + subBuilder.MergeFrom(Resampler); + } + input.ReadMessage(subBuilder); + Resampler = subBuilder; + break; + } + case 18: { + Error = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + global::LiveKit.Proto.OwnedSoxResampler subBuilder = new global::LiveKit.Proto.OwnedSoxResampler(); + if (messageCase_ == MessageOneofCase.Resampler) { + subBuilder.MergeFrom(Resampler); + } + input.ReadMessage(subBuilder); + Resampler = subBuilder; + break; + } + case 18: { + Error = input.ReadString(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class PushSoxResamplerRequest : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new PushSoxResamplerRequest()); + private pb::UnknownFieldSet _unknownFields; + private int _hasBits0; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.AudioFrameReflection.Descriptor.MessageTypes[25]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public PushSoxResamplerRequest() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public PushSoxResamplerRequest(PushSoxResamplerRequest other) : this() { + _hasBits0 = other._hasBits0; + resamplerHandle_ = other.resamplerHandle_; + dataPtr_ = other.dataPtr_; + size_ = other.size_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public PushSoxResamplerRequest Clone() { + return new PushSoxResamplerRequest(this); + } + + /// Field number for the "resampler_handle" field. + public const int ResamplerHandleFieldNumber = 1; + private readonly static ulong ResamplerHandleDefaultValue = 0UL; + + private ulong resamplerHandle_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ulong ResamplerHandle { + get { if ((_hasBits0 & 1) != 0) { return resamplerHandle_; } else { return ResamplerHandleDefaultValue; } } + set { + _hasBits0 |= 1; + resamplerHandle_ = value; + } + } + /// Gets whether the "resampler_handle" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasResamplerHandle { + get { return (_hasBits0 & 1) != 0; } + } + /// Clears the value of the "resampler_handle" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearResamplerHandle() { + _hasBits0 &= ~1; + } + + /// Field number for the "data_ptr" field. + public const int DataPtrFieldNumber = 2; + private readonly static ulong DataPtrDefaultValue = 0UL; + + private ulong dataPtr_; + /// + /// *const i16 + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ulong DataPtr { + get { if ((_hasBits0 & 2) != 0) { return dataPtr_; } else { return DataPtrDefaultValue; } } + set { + _hasBits0 |= 2; + dataPtr_ = value; + } + } + /// Gets whether the "data_ptr" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasDataPtr { + get { return (_hasBits0 & 2) != 0; } + } + /// Clears the value of the "data_ptr" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearDataPtr() { + _hasBits0 &= ~2; + } + + /// Field number for the "size" field. + public const int SizeFieldNumber = 3; + private readonly static uint SizeDefaultValue = 0; + + private uint size_; + /// + /// in bytes + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public uint Size { + get { if ((_hasBits0 & 4) != 0) { return size_; } else { return SizeDefaultValue; } } + set { + _hasBits0 |= 4; + size_ = value; + } + } + /// Gets whether the "size" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasSize { + get { return (_hasBits0 & 4) != 0; } + } + /// Clears the value of the "size" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearSize() { + _hasBits0 &= ~4; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as PushSoxResamplerRequest); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(PushSoxResamplerRequest other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (ResamplerHandle != other.ResamplerHandle) return false; + if (DataPtr != other.DataPtr) return false; + if (Size != other.Size) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (HasResamplerHandle) hash ^= ResamplerHandle.GetHashCode(); + if (HasDataPtr) hash ^= DataPtr.GetHashCode(); + if (HasSize) hash ^= Size.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (HasResamplerHandle) { + output.WriteRawTag(8); + output.WriteUInt64(ResamplerHandle); + } + if (HasDataPtr) { + output.WriteRawTag(16); + output.WriteUInt64(DataPtr); + } + if (HasSize) { + output.WriteRawTag(24); + output.WriteUInt32(Size); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (HasResamplerHandle) { + output.WriteRawTag(8); + output.WriteUInt64(ResamplerHandle); + } + if (HasDataPtr) { + output.WriteRawTag(16); + output.WriteUInt64(DataPtr); + } + if (HasSize) { + output.WriteRawTag(24); + output.WriteUInt32(Size); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (HasResamplerHandle) { + size += 1 + pb::CodedOutputStream.ComputeUInt64Size(ResamplerHandle); + } + if (HasDataPtr) { + size += 1 + pb::CodedOutputStream.ComputeUInt64Size(DataPtr); + } + if (HasSize) { + size += 1 + pb::CodedOutputStream.ComputeUInt32Size(Size); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(PushSoxResamplerRequest other) { + if (other == null) { + return; + } + if (other.HasResamplerHandle) { + ResamplerHandle = other.ResamplerHandle; + } + if (other.HasDataPtr) { + DataPtr = other.DataPtr; + } + if (other.HasSize) { + Size = other.Size; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + ResamplerHandle = input.ReadUInt64(); + break; + } + case 16: { + DataPtr = input.ReadUInt64(); + break; + } + case 24: { + Size = input.ReadUInt32(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + ResamplerHandle = input.ReadUInt64(); + break; + } + case 16: { + DataPtr = input.ReadUInt64(); + break; + } + case 24: { + Size = input.ReadUInt32(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class PushSoxResamplerResponse : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new PushSoxResamplerResponse()); + private pb::UnknownFieldSet _unknownFields; + private int _hasBits0; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.AudioFrameReflection.Descriptor.MessageTypes[26]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public PushSoxResamplerResponse() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public PushSoxResamplerResponse(PushSoxResamplerResponse other) : this() { + _hasBits0 = other._hasBits0; + outputPtr_ = other.outputPtr_; + size_ = other.size_; + error_ = other.error_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public PushSoxResamplerResponse Clone() { + return new PushSoxResamplerResponse(this); + } + + /// Field number for the "output_ptr" field. + public const int OutputPtrFieldNumber = 1; + private readonly static ulong OutputPtrDefaultValue = 0UL; + + private ulong outputPtr_; + /// + /// *const i16 (could be null) + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ulong OutputPtr { + get { if ((_hasBits0 & 1) != 0) { return outputPtr_; } else { return OutputPtrDefaultValue; } } + set { + _hasBits0 |= 1; + outputPtr_ = value; + } + } + /// Gets whether the "output_ptr" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasOutputPtr { + get { return (_hasBits0 & 1) != 0; } + } + /// Clears the value of the "output_ptr" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearOutputPtr() { + _hasBits0 &= ~1; + } + + /// Field number for the "size" field. + public const int SizeFieldNumber = 2; + private readonly static uint SizeDefaultValue = 0; + + private uint size_; + /// + /// in bytes + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public uint Size { + get { if ((_hasBits0 & 2) != 0) { return size_; } else { return SizeDefaultValue; } } + set { + _hasBits0 |= 2; + size_ = value; + } + } + /// Gets whether the "size" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasSize { + get { return (_hasBits0 & 2) != 0; } + } + /// Clears the value of the "size" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearSize() { + _hasBits0 &= ~2; + } + + /// Field number for the "error" field. + public const int ErrorFieldNumber = 3; + private readonly static string ErrorDefaultValue = ""; + + private string error_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Error { + get { return error_ ?? ErrorDefaultValue; } + set { + error_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + /// Gets whether the "error" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasError { + get { return error_ != null; } + } + /// Clears the value of the "error" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearError() { + error_ = null; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as PushSoxResamplerResponse); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(PushSoxResamplerResponse other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (OutputPtr != other.OutputPtr) return false; + if (Size != other.Size) return false; + if (Error != other.Error) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (HasOutputPtr) hash ^= OutputPtr.GetHashCode(); + if (HasSize) hash ^= Size.GetHashCode(); + if (HasError) hash ^= Error.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (HasOutputPtr) { + output.WriteRawTag(8); + output.WriteUInt64(OutputPtr); + } + if (HasSize) { + output.WriteRawTag(16); + output.WriteUInt32(Size); + } + if (HasError) { + output.WriteRawTag(26); + output.WriteString(Error); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (HasOutputPtr) { + output.WriteRawTag(8); + output.WriteUInt64(OutputPtr); + } + if (HasSize) { + output.WriteRawTag(16); + output.WriteUInt32(Size); + } + if (HasError) { + output.WriteRawTag(26); + output.WriteString(Error); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (HasOutputPtr) { + size += 1 + pb::CodedOutputStream.ComputeUInt64Size(OutputPtr); + } + if (HasSize) { + size += 1 + pb::CodedOutputStream.ComputeUInt32Size(Size); + } + if (HasError) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Error); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(PushSoxResamplerResponse other) { + if (other == null) { + return; + } + if (other.HasOutputPtr) { + OutputPtr = other.OutputPtr; + } + if (other.HasSize) { + Size = other.Size; + } + if (other.HasError) { + Error = other.Error; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + OutputPtr = input.ReadUInt64(); + break; + } + case 16: { + Size = input.ReadUInt32(); + break; + } + case 26: { + Error = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + OutputPtr = input.ReadUInt64(); + break; + } + case 16: { + Size = input.ReadUInt32(); + break; + } + case 26: { + Error = input.ReadString(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class FlushSoxResamplerRequest : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new FlushSoxResamplerRequest()); + private pb::UnknownFieldSet _unknownFields; + private int _hasBits0; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.AudioFrameReflection.Descriptor.MessageTypes[27]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public FlushSoxResamplerRequest() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public FlushSoxResamplerRequest(FlushSoxResamplerRequest other) : this() { + _hasBits0 = other._hasBits0; + resamplerHandle_ = other.resamplerHandle_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public FlushSoxResamplerRequest Clone() { + return new FlushSoxResamplerRequest(this); + } + + /// Field number for the "resampler_handle" field. + public const int ResamplerHandleFieldNumber = 1; + private readonly static ulong ResamplerHandleDefaultValue = 0UL; + + private ulong resamplerHandle_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ulong ResamplerHandle { + get { if ((_hasBits0 & 1) != 0) { return resamplerHandle_; } else { return ResamplerHandleDefaultValue; } } + set { + _hasBits0 |= 1; + resamplerHandle_ = value; + } + } + /// Gets whether the "resampler_handle" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasResamplerHandle { + get { return (_hasBits0 & 1) != 0; } + } + /// Clears the value of the "resampler_handle" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearResamplerHandle() { + _hasBits0 &= ~1; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as FlushSoxResamplerRequest); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(FlushSoxResamplerRequest other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (ResamplerHandle != other.ResamplerHandle) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (HasResamplerHandle) hash ^= ResamplerHandle.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (HasResamplerHandle) { + output.WriteRawTag(8); + output.WriteUInt64(ResamplerHandle); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (HasResamplerHandle) { + output.WriteRawTag(8); + output.WriteUInt64(ResamplerHandle); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (HasResamplerHandle) { + size += 1 + pb::CodedOutputStream.ComputeUInt64Size(ResamplerHandle); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(FlushSoxResamplerRequest other) { + if (other == null) { + return; + } + if (other.HasResamplerHandle) { + ResamplerHandle = other.ResamplerHandle; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + ResamplerHandle = input.ReadUInt64(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + ResamplerHandle = input.ReadUInt64(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class FlushSoxResamplerResponse : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new FlushSoxResamplerResponse()); + private pb::UnknownFieldSet _unknownFields; + private int _hasBits0; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.AudioFrameReflection.Descriptor.MessageTypes[28]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public FlushSoxResamplerResponse() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public FlushSoxResamplerResponse(FlushSoxResamplerResponse other) : this() { + _hasBits0 = other._hasBits0; + outputPtr_ = other.outputPtr_; + size_ = other.size_; + error_ = other.error_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public FlushSoxResamplerResponse Clone() { + return new FlushSoxResamplerResponse(this); + } + + /// Field number for the "output_ptr" field. + public const int OutputPtrFieldNumber = 1; + private readonly static ulong OutputPtrDefaultValue = 0UL; + + private ulong outputPtr_; + /// + /// *const i16 (could be null) + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ulong OutputPtr { + get { if ((_hasBits0 & 1) != 0) { return outputPtr_; } else { return OutputPtrDefaultValue; } } + set { + _hasBits0 |= 1; + outputPtr_ = value; + } + } + /// Gets whether the "output_ptr" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasOutputPtr { + get { return (_hasBits0 & 1) != 0; } + } + /// Clears the value of the "output_ptr" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearOutputPtr() { + _hasBits0 &= ~1; + } + + /// Field number for the "size" field. + public const int SizeFieldNumber = 2; + private readonly static uint SizeDefaultValue = 0; + + private uint size_; + /// + /// in bytes + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public uint Size { + get { if ((_hasBits0 & 2) != 0) { return size_; } else { return SizeDefaultValue; } } + set { + _hasBits0 |= 2; + size_ = value; + } + } + /// Gets whether the "size" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasSize { + get { return (_hasBits0 & 2) != 0; } + } + /// Clears the value of the "size" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearSize() { + _hasBits0 &= ~2; + } + + /// Field number for the "error" field. + public const int ErrorFieldNumber = 3; + private readonly static string ErrorDefaultValue = ""; + + private string error_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Error { + get { return error_ ?? ErrorDefaultValue; } + set { + error_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + /// Gets whether the "error" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasError { + get { return error_ != null; } + } + /// Clears the value of the "error" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearError() { + error_ = null; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as FlushSoxResamplerResponse); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(FlushSoxResamplerResponse other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (OutputPtr != other.OutputPtr) return false; + if (Size != other.Size) return false; + if (Error != other.Error) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (HasOutputPtr) hash ^= OutputPtr.GetHashCode(); + if (HasSize) hash ^= Size.GetHashCode(); + if (HasError) hash ^= Error.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (HasOutputPtr) { + output.WriteRawTag(8); + output.WriteUInt64(OutputPtr); + } + if (HasSize) { + output.WriteRawTag(16); + output.WriteUInt32(Size); + } + if (HasError) { + output.WriteRawTag(26); + output.WriteString(Error); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (HasOutputPtr) { + output.WriteRawTag(8); + output.WriteUInt64(OutputPtr); + } + if (HasSize) { + output.WriteRawTag(16); + output.WriteUInt32(Size); + } + if (HasError) { + output.WriteRawTag(26); + output.WriteString(Error); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (HasOutputPtr) { + size += 1 + pb::CodedOutputStream.ComputeUInt64Size(OutputPtr); + } + if (HasSize) { + size += 1 + pb::CodedOutputStream.ComputeUInt32Size(Size); + } + if (HasError) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Error); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(FlushSoxResamplerResponse other) { + if (other == null) { + return; + } + if (other.HasOutputPtr) { + OutputPtr = other.OutputPtr; + } + if (other.HasSize) { + Size = other.Size; + } + if (other.HasError) { + Error = other.Error; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + OutputPtr = input.ReadUInt64(); + break; + } + case 16: { + Size = input.ReadUInt32(); + break; + } + case 26: { + Error = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + OutputPtr = input.ReadUInt64(); + break; + } + case 16: { + Size = input.ReadUInt32(); + break; + } + case 26: { + Error = input.ReadString(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class AudioFrameBufferInfo : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new AudioFrameBufferInfo()); + private pb::UnknownFieldSet _unknownFields; + private int _hasBits0; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.AudioFrameReflection.Descriptor.MessageTypes[29]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public AudioFrameBufferInfo() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public AudioFrameBufferInfo(AudioFrameBufferInfo other) : this() { + _hasBits0 = other._hasBits0; + dataPtr_ = other.dataPtr_; + numChannels_ = other.numChannels_; + sampleRate_ = other.sampleRate_; + samplesPerChannel_ = other.samplesPerChannel_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public AudioFrameBufferInfo Clone() { + return new AudioFrameBufferInfo(this); + } + + /// Field number for the "data_ptr" field. + public const int DataPtrFieldNumber = 1; + private readonly static ulong DataPtrDefaultValue = 0UL; + + private ulong dataPtr_; + /// + /// *const i16 + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ulong DataPtr { + get { if ((_hasBits0 & 1) != 0) { return dataPtr_; } else { return DataPtrDefaultValue; } } + set { + _hasBits0 |= 1; + dataPtr_ = value; + } + } + /// Gets whether the "data_ptr" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasDataPtr { + get { return (_hasBits0 & 1) != 0; } + } + /// Clears the value of the "data_ptr" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearDataPtr() { + _hasBits0 &= ~1; + } + + /// Field number for the "num_channels" field. + public const int NumChannelsFieldNumber = 2; + private readonly static uint NumChannelsDefaultValue = 0; + + private uint numChannels_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public uint NumChannels { + get { if ((_hasBits0 & 2) != 0) { return numChannels_; } else { return NumChannelsDefaultValue; } } + set { + _hasBits0 |= 2; + numChannels_ = value; + } + } + /// Gets whether the "num_channels" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasNumChannels { + get { return (_hasBits0 & 2) != 0; } + } + /// Clears the value of the "num_channels" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearNumChannels() { + _hasBits0 &= ~2; + } + + /// Field number for the "sample_rate" field. + public const int SampleRateFieldNumber = 3; + private readonly static uint SampleRateDefaultValue = 0; + + private uint sampleRate_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public uint SampleRate { + get { if ((_hasBits0 & 4) != 0) { return sampleRate_; } else { return SampleRateDefaultValue; } } + set { + _hasBits0 |= 4; + sampleRate_ = value; + } + } + /// Gets whether the "sample_rate" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasSampleRate { + get { return (_hasBits0 & 4) != 0; } + } + /// Clears the value of the "sample_rate" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearSampleRate() { + _hasBits0 &= ~4; + } + + /// Field number for the "samples_per_channel" field. + public const int SamplesPerChannelFieldNumber = 4; + private readonly static uint SamplesPerChannelDefaultValue = 0; + + private uint samplesPerChannel_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public uint SamplesPerChannel { + get { if ((_hasBits0 & 8) != 0) { return samplesPerChannel_; } else { return SamplesPerChannelDefaultValue; } } + set { + _hasBits0 |= 8; + samplesPerChannel_ = value; + } + } + /// Gets whether the "samples_per_channel" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasSamplesPerChannel { + get { return (_hasBits0 & 8) != 0; } + } + /// Clears the value of the "samples_per_channel" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearSamplesPerChannel() { + _hasBits0 &= ~8; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as AudioFrameBufferInfo); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(AudioFrameBufferInfo other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (DataPtr != other.DataPtr) return false; + if (NumChannels != other.NumChannels) return false; + if (SampleRate != other.SampleRate) return false; + if (SamplesPerChannel != other.SamplesPerChannel) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (HasDataPtr) hash ^= DataPtr.GetHashCode(); + if (HasNumChannels) hash ^= NumChannels.GetHashCode(); + if (HasSampleRate) hash ^= SampleRate.GetHashCode(); + if (HasSamplesPerChannel) hash ^= SamplesPerChannel.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (HasDataPtr) { + output.WriteRawTag(8); + output.WriteUInt64(DataPtr); + } + if (HasNumChannels) { + output.WriteRawTag(16); + output.WriteUInt32(NumChannels); + } + if (HasSampleRate) { + output.WriteRawTag(24); + output.WriteUInt32(SampleRate); + } + if (HasSamplesPerChannel) { + output.WriteRawTag(32); + output.WriteUInt32(SamplesPerChannel); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (HasDataPtr) { + output.WriteRawTag(8); + output.WriteUInt64(DataPtr); + } + if (HasNumChannels) { + output.WriteRawTag(16); + output.WriteUInt32(NumChannels); + } + if (HasSampleRate) { + output.WriteRawTag(24); + output.WriteUInt32(SampleRate); + } + if (HasSamplesPerChannel) { + output.WriteRawTag(32); + output.WriteUInt32(SamplesPerChannel); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (HasDataPtr) { + size += 1 + pb::CodedOutputStream.ComputeUInt64Size(DataPtr); + } + if (HasNumChannels) { + size += 1 + pb::CodedOutputStream.ComputeUInt32Size(NumChannels); + } + if (HasSampleRate) { + size += 1 + pb::CodedOutputStream.ComputeUInt32Size(SampleRate); + } + if (HasSamplesPerChannel) { + size += 1 + pb::CodedOutputStream.ComputeUInt32Size(SamplesPerChannel); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(AudioFrameBufferInfo other) { + if (other == null) { + return; + } + if (other.HasDataPtr) { + DataPtr = other.DataPtr; + } + if (other.HasNumChannels) { + NumChannels = other.NumChannels; + } + if (other.HasSampleRate) { + SampleRate = other.SampleRate; + } + if (other.HasSamplesPerChannel) { + SamplesPerChannel = other.SamplesPerChannel; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + DataPtr = input.ReadUInt64(); + break; + } + case 16: { + NumChannels = input.ReadUInt32(); + break; + } + case 24: { + SampleRate = input.ReadUInt32(); + break; + } + case 32: { + SamplesPerChannel = input.ReadUInt32(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + DataPtr = input.ReadUInt64(); + break; + } + case 16: { + NumChannels = input.ReadUInt32(); + break; + } + case 24: { + SampleRate = input.ReadUInt32(); + break; + } + case 32: { + SamplesPerChannel = input.ReadUInt32(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class OwnedAudioFrameBuffer : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new OwnedAudioFrameBuffer()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.AudioFrameReflection.Descriptor.MessageTypes[30]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public OwnedAudioFrameBuffer() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public OwnedAudioFrameBuffer(OwnedAudioFrameBuffer other) : this() { + handle_ = other.handle_ != null ? other.handle_.Clone() : null; + info_ = other.info_ != null ? other.info_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public OwnedAudioFrameBuffer Clone() { + return new OwnedAudioFrameBuffer(this); + } + + /// Field number for the "handle" field. + public const int HandleFieldNumber = 1; + private global::LiveKit.Proto.FfiOwnedHandle handle_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.FfiOwnedHandle Handle { + get { return handle_; } + set { + handle_ = value; + } + } + + /// Field number for the "info" field. + public const int InfoFieldNumber = 2; + private global::LiveKit.Proto.AudioFrameBufferInfo info_; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public void ClearResamplerHandle() { - _hasBits0 &= ~1; + public global::LiveKit.Proto.AudioFrameBufferInfo Info { + get { return info_; } + set { + info_ = value; + } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override bool Equals(object other) { - return Equals(other as FlushSoxResamplerRequest); + return Equals(other as OwnedAudioFrameBuffer); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool Equals(FlushSoxResamplerRequest other) { + public bool Equals(OwnedAudioFrameBuffer other) { if (ReferenceEquals(other, null)) { return false; } if (ReferenceEquals(other, this)) { return true; } - if (ResamplerHandle != other.ResamplerHandle) return false; + if (!object.Equals(Handle, other.Handle)) return false; + if (!object.Equals(Info, other.Info)) return false; return Equals(_unknownFields, other._unknownFields); } @@ -5685,7 +9174,8 @@ public bool Equals(FlushSoxResamplerRequest other) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override int GetHashCode() { int hash = 1; - if (HasResamplerHandle) hash ^= ResamplerHandle.GetHashCode(); + if (handle_ != null) hash ^= Handle.GetHashCode(); + if (info_ != null) hash ^= Info.GetHashCode(); if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } @@ -5704,9 +9194,13 @@ public void WriteTo(pb::CodedOutputStream output) { #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE output.WriteRawMessage(this); #else - if (HasResamplerHandle) { - output.WriteRawTag(8); - output.WriteUInt64(ResamplerHandle); + if (handle_ != null) { + output.WriteRawTag(10); + output.WriteMessage(Handle); + } + if (info_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Info); } if (_unknownFields != null) { _unknownFields.WriteTo(output); @@ -5718,9 +9212,13 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { - if (HasResamplerHandle) { - output.WriteRawTag(8); - output.WriteUInt64(ResamplerHandle); + if (handle_ != null) { + output.WriteRawTag(10); + output.WriteMessage(Handle); + } + if (info_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Info); } if (_unknownFields != null) { _unknownFields.WriteTo(ref output); @@ -5732,8 +9230,11 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public int CalculateSize() { int size = 0; - if (HasResamplerHandle) { - size += 1 + pb::CodedOutputStream.ComputeUInt64Size(ResamplerHandle); + if (handle_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Handle); + } + if (info_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Info); } if (_unknownFields != null) { size += _unknownFields.CalculateSize(); @@ -5743,12 +9244,21 @@ public int CalculateSize() { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public void MergeFrom(FlushSoxResamplerRequest other) { + public void MergeFrom(OwnedAudioFrameBuffer other) { if (other == null) { return; } - if (other.HasResamplerHandle) { - ResamplerHandle = other.ResamplerHandle; + if (other.handle_ != null) { + if (handle_ == null) { + Handle = new global::LiveKit.Proto.FfiOwnedHandle(); + } + Handle.MergeFrom(other.Handle); + } + if (other.info_ != null) { + if (info_ == null) { + Info = new global::LiveKit.Proto.AudioFrameBufferInfo(); + } + Info.MergeFrom(other.Info); } _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); } @@ -5769,8 +9279,18 @@ public void MergeFrom(pb::CodedInputStream input) { default: _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); break; - case 8: { - ResamplerHandle = input.ReadUInt64(); + case 10: { + if (handle_ == null) { + Handle = new global::LiveKit.Proto.FfiOwnedHandle(); + } + input.ReadMessage(Handle); + break; + } + case 18: { + if (info_ == null) { + Info = new global::LiveKit.Proto.AudioFrameBufferInfo(); + } + input.ReadMessage(Info); break; } } @@ -5792,8 +9312,18 @@ public void MergeFrom(pb::CodedInputStream input) { default: _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); break; - case 8: { - ResamplerHandle = input.ReadUInt64(); + case 10: { + if (handle_ == null) { + Handle = new global::LiveKit.Proto.FfiOwnedHandle(); + } + input.ReadMessage(Handle); + break; + } + case 18: { + if (info_ == null) { + Info = new global::LiveKit.Proto.AudioFrameBufferInfo(); + } + input.ReadMessage(Info); break; } } @@ -5804,22 +9334,22 @@ public void MergeFrom(pb::CodedInputStream input) { } [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] - public sealed partial class FlushSoxResamplerResponse : pb::IMessage + public sealed partial class AudioStreamInfo : pb::IMessage #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE , pb::IBufferMessage #endif { - private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new FlushSoxResamplerResponse()); + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new AudioStreamInfo()); private pb::UnknownFieldSet _unknownFields; private int _hasBits0; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public static pb::MessageParser Parser { get { return _parser; } } + public static pb::MessageParser Parser { get { return _parser; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::LiveKit.Proto.AudioFrameReflection.Descriptor.MessageTypes[20]; } + get { return global::LiveKit.Proto.AudioFrameReflection.Descriptor.MessageTypes[31]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -5830,7 +9360,7 @@ public sealed partial class FlushSoxResamplerResponse : pb::IMessageField number for the "output_ptr" field. - public const int OutputPtrFieldNumber = 1; - private readonly static ulong OutputPtrDefaultValue = 0UL; + /// Field number for the "type" field. + public const int TypeFieldNumber = 1; + private readonly static global::LiveKit.Proto.AudioStreamType TypeDefaultValue = global::LiveKit.Proto.AudioStreamType.AudioStreamNative; - private ulong outputPtr_; - /// - /// *const i16 (could be null) - /// + private global::LiveKit.Proto.AudioStreamType type_; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public ulong OutputPtr { - get { if ((_hasBits0 & 1) != 0) { return outputPtr_; } else { return OutputPtrDefaultValue; } } + public global::LiveKit.Proto.AudioStreamType Type { + get { if ((_hasBits0 & 1) != 0) { return type_; } else { return TypeDefaultValue; } } set { _hasBits0 |= 1; - outputPtr_ = value; + type_ = value; } } - /// Gets whether the "output_ptr" field is set + /// Gets whether the "type" field is set [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool HasOutputPtr { + public bool HasType { get { return (_hasBits0 & 1) != 0; } } - /// Clears the value of the "output_ptr" field + /// Clears the value of the "type" field [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public void ClearOutputPtr() { + public void ClearType() { _hasBits0 &= ~1; } - /// Field number for the "size" field. - public const int SizeFieldNumber = 2; - private readonly static uint SizeDefaultValue = 0; - - private uint size_; - /// - /// in bytes - /// - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public uint Size { - get { if ((_hasBits0 & 2) != 0) { return size_; } else { return SizeDefaultValue; } } - set { - _hasBits0 |= 2; - size_ = value; - } - } - /// Gets whether the "size" field is set - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool HasSize { - get { return (_hasBits0 & 2) != 0; } - } - /// Clears the value of the "size" field - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public void ClearSize() { - _hasBits0 &= ~2; - } - - /// Field number for the "error" field. - public const int ErrorFieldNumber = 3; - private readonly static string ErrorDefaultValue = ""; - - private string error_; - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public string Error { - get { return error_ ?? ErrorDefaultValue; } - set { - error_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); - } - } - /// Gets whether the "error" field is set - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool HasError { - get { return error_ != null; } - } - /// Clears the value of the "error" field - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public void ClearError() { - error_ = null; - } - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override bool Equals(object other) { - return Equals(other as FlushSoxResamplerResponse); + return Equals(other as AudioStreamInfo); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool Equals(FlushSoxResamplerResponse other) { + public bool Equals(AudioStreamInfo other) { if (ReferenceEquals(other, null)) { return false; } if (ReferenceEquals(other, this)) { return true; } - if (OutputPtr != other.OutputPtr) return false; - if (Size != other.Size) return false; - if (Error != other.Error) return false; + if (Type != other.Type) return false; return Equals(_unknownFields, other._unknownFields); } @@ -5963,9 +9430,7 @@ public bool Equals(FlushSoxResamplerResponse other) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override int GetHashCode() { int hash = 1; - if (HasOutputPtr) hash ^= OutputPtr.GetHashCode(); - if (HasSize) hash ^= Size.GetHashCode(); - if (HasError) hash ^= Error.GetHashCode(); + if (HasType) hash ^= Type.GetHashCode(); if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } @@ -5984,17 +9449,9 @@ public void WriteTo(pb::CodedOutputStream output) { #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE output.WriteRawMessage(this); #else - if (HasOutputPtr) { + if (HasType) { output.WriteRawTag(8); - output.WriteUInt64(OutputPtr); - } - if (HasSize) { - output.WriteRawTag(16); - output.WriteUInt32(Size); - } - if (HasError) { - output.WriteRawTag(26); - output.WriteString(Error); + output.WriteEnum((int) Type); } if (_unknownFields != null) { _unknownFields.WriteTo(output); @@ -6006,17 +9463,9 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { - if (HasOutputPtr) { + if (HasType) { output.WriteRawTag(8); - output.WriteUInt64(OutputPtr); - } - if (HasSize) { - output.WriteRawTag(16); - output.WriteUInt32(Size); - } - if (HasError) { - output.WriteRawTag(26); - output.WriteString(Error); + output.WriteEnum((int) Type); } if (_unknownFields != null) { _unknownFields.WriteTo(ref output); @@ -6028,14 +9477,8 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public int CalculateSize() { int size = 0; - if (HasOutputPtr) { - size += 1 + pb::CodedOutputStream.ComputeUInt64Size(OutputPtr); - } - if (HasSize) { - size += 1 + pb::CodedOutputStream.ComputeUInt32Size(Size); - } - if (HasError) { - size += 1 + pb::CodedOutputStream.ComputeStringSize(Error); + if (HasType) { + size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) Type); } if (_unknownFields != null) { size += _unknownFields.CalculateSize(); @@ -6045,18 +9488,12 @@ public int CalculateSize() { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public void MergeFrom(FlushSoxResamplerResponse other) { + public void MergeFrom(AudioStreamInfo other) { if (other == null) { return; } - if (other.HasOutputPtr) { - OutputPtr = other.OutputPtr; - } - if (other.HasSize) { - Size = other.Size; - } - if (other.HasError) { - Error = other.Error; + if (other.HasType) { + Type = other.Type; } _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); } @@ -6078,15 +9515,7 @@ public void MergeFrom(pb::CodedInputStream input) { _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); break; case 8: { - OutputPtr = input.ReadUInt64(); - break; - } - case 16: { - Size = input.ReadUInt32(); - break; - } - case 26: { - Error = input.ReadString(); + Type = (global::LiveKit.Proto.AudioStreamType) input.ReadEnum(); break; } } @@ -6109,15 +9538,7 @@ public void MergeFrom(pb::CodedInputStream input) { _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); break; case 8: { - OutputPtr = input.ReadUInt64(); - break; - } - case 16: { - Size = input.ReadUInt32(); - break; - } - case 26: { - Error = input.ReadString(); + Type = (global::LiveKit.Proto.AudioStreamType) input.ReadEnum(); break; } } @@ -6128,22 +9549,21 @@ public void MergeFrom(pb::CodedInputStream input) { } [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] - public sealed partial class AudioFrameBufferInfo : pb::IMessage + public sealed partial class OwnedAudioStream : pb::IMessage #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE , pb::IBufferMessage #endif { - private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new AudioFrameBufferInfo()); + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new OwnedAudioStream()); private pb::UnknownFieldSet _unknownFields; - private int _hasBits0; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public static pb::MessageParser Parser { get { return _parser; } } + public static pb::MessageParser Parser { get { return _parser; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::LiveKit.Proto.AudioFrameReflection.Descriptor.MessageTypes[21]; } + get { return global::LiveKit.Proto.AudioFrameReflection.Descriptor.MessageTypes[32]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -6154,7 +9574,7 @@ public sealed partial class AudioFrameBufferInfo : pb::IMessageField number for the "data_ptr" field. - public const int DataPtrFieldNumber = 1; - private readonly static ulong DataPtrDefaultValue = 0UL; - - private ulong dataPtr_; - /// - /// *const i16 - /// - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public ulong DataPtr { - get { if ((_hasBits0 & 1) != 0) { return dataPtr_; } else { return DataPtrDefaultValue; } } - set { - _hasBits0 |= 1; - dataPtr_ = value; - } - } - /// Gets whether the "data_ptr" field is set - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool HasDataPtr { - get { return (_hasBits0 & 1) != 0; } - } - /// Clears the value of the "data_ptr" field - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public void ClearDataPtr() { - _hasBits0 &= ~1; - } - - /// Field number for the "num_channels" field. - public const int NumChannelsFieldNumber = 2; - private readonly static uint NumChannelsDefaultValue = 0; - - private uint numChannels_; - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public uint NumChannels { - get { if ((_hasBits0 & 2) != 0) { return numChannels_; } else { return NumChannelsDefaultValue; } } - set { - _hasBits0 |= 2; - numChannels_ = value; - } - } - /// Gets whether the "num_channels" field is set - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool HasNumChannels { - get { return (_hasBits0 & 2) != 0; } - } - /// Clears the value of the "num_channels" field - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public void ClearNumChannels() { - _hasBits0 &= ~2; + public OwnedAudioStream Clone() { + return new OwnedAudioStream(this); } - /// Field number for the "sample_rate" field. - public const int SampleRateFieldNumber = 3; - private readonly static uint SampleRateDefaultValue = 0; - - private uint sampleRate_; + /// Field number for the "handle" field. + public const int HandleFieldNumber = 1; + private global::LiveKit.Proto.FfiOwnedHandle handle_; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public uint SampleRate { - get { if ((_hasBits0 & 4) != 0) { return sampleRate_; } else { return SampleRateDefaultValue; } } + public global::LiveKit.Proto.FfiOwnedHandle Handle { + get { return handle_; } set { - _hasBits0 |= 4; - sampleRate_ = value; + handle_ = value; } } - /// Gets whether the "sample_rate" field is set - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool HasSampleRate { - get { return (_hasBits0 & 4) != 0; } - } - /// Clears the value of the "sample_rate" field - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public void ClearSampleRate() { - _hasBits0 &= ~4; - } - /// Field number for the "samples_per_channel" field. - public const int SamplesPerChannelFieldNumber = 4; - private readonly static uint SamplesPerChannelDefaultValue = 0; - - private uint samplesPerChannel_; + /// Field number for the "info" field. + public const int InfoFieldNumber = 2; + private global::LiveKit.Proto.AudioStreamInfo info_; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public uint SamplesPerChannel { - get { if ((_hasBits0 & 8) != 0) { return samplesPerChannel_; } else { return SamplesPerChannelDefaultValue; } } + public global::LiveKit.Proto.AudioStreamInfo Info { + get { return info_; } set { - _hasBits0 |= 8; - samplesPerChannel_ = value; + info_ = value; } } - /// Gets whether the "samples_per_channel" field is set - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool HasSamplesPerChannel { - get { return (_hasBits0 & 8) != 0; } - } - /// Clears the value of the "samples_per_channel" field - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public void ClearSamplesPerChannel() { - _hasBits0 &= ~8; - } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override bool Equals(object other) { - return Equals(other as AudioFrameBufferInfo); + return Equals(other as OwnedAudioStream); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool Equals(AudioFrameBufferInfo other) { + public bool Equals(OwnedAudioStream other) { if (ReferenceEquals(other, null)) { return false; } if (ReferenceEquals(other, this)) { return true; } - if (DataPtr != other.DataPtr) return false; - if (NumChannels != other.NumChannels) return false; - if (SampleRate != other.SampleRate) return false; - if (SamplesPerChannel != other.SamplesPerChannel) return false; + if (!object.Equals(Handle, other.Handle)) return false; + if (!object.Equals(Info, other.Info)) return false; return Equals(_unknownFields, other._unknownFields); } @@ -6314,10 +9642,8 @@ public bool Equals(AudioFrameBufferInfo other) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override int GetHashCode() { int hash = 1; - if (HasDataPtr) hash ^= DataPtr.GetHashCode(); - if (HasNumChannels) hash ^= NumChannels.GetHashCode(); - if (HasSampleRate) hash ^= SampleRate.GetHashCode(); - if (HasSamplesPerChannel) hash ^= SamplesPerChannel.GetHashCode(); + if (handle_ != null) hash ^= Handle.GetHashCode(); + if (info_ != null) hash ^= Info.GetHashCode(); if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } @@ -6336,21 +9662,13 @@ public void WriteTo(pb::CodedOutputStream output) { #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE output.WriteRawMessage(this); #else - if (HasDataPtr) { - output.WriteRawTag(8); - output.WriteUInt64(DataPtr); - } - if (HasNumChannels) { - output.WriteRawTag(16); - output.WriteUInt32(NumChannels); - } - if (HasSampleRate) { - output.WriteRawTag(24); - output.WriteUInt32(SampleRate); + if (handle_ != null) { + output.WriteRawTag(10); + output.WriteMessage(Handle); } - if (HasSamplesPerChannel) { - output.WriteRawTag(32); - output.WriteUInt32(SamplesPerChannel); + if (info_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Info); } if (_unknownFields != null) { _unknownFields.WriteTo(output); @@ -6362,21 +9680,13 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { - if (HasDataPtr) { - output.WriteRawTag(8); - output.WriteUInt64(DataPtr); - } - if (HasNumChannels) { - output.WriteRawTag(16); - output.WriteUInt32(NumChannels); - } - if (HasSampleRate) { - output.WriteRawTag(24); - output.WriteUInt32(SampleRate); + if (handle_ != null) { + output.WriteRawTag(10); + output.WriteMessage(Handle); } - if (HasSamplesPerChannel) { - output.WriteRawTag(32); - output.WriteUInt32(SamplesPerChannel); + if (info_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Info); } if (_unknownFields != null) { _unknownFields.WriteTo(ref output); @@ -6388,17 +9698,11 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public int CalculateSize() { int size = 0; - if (HasDataPtr) { - size += 1 + pb::CodedOutputStream.ComputeUInt64Size(DataPtr); - } - if (HasNumChannels) { - size += 1 + pb::CodedOutputStream.ComputeUInt32Size(NumChannels); - } - if (HasSampleRate) { - size += 1 + pb::CodedOutputStream.ComputeUInt32Size(SampleRate); + if (handle_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Handle); } - if (HasSamplesPerChannel) { - size += 1 + pb::CodedOutputStream.ComputeUInt32Size(SamplesPerChannel); + if (info_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Info); } if (_unknownFields != null) { size += _unknownFields.CalculateSize(); @@ -6408,21 +9712,21 @@ public int CalculateSize() { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public void MergeFrom(AudioFrameBufferInfo other) { + public void MergeFrom(OwnedAudioStream other) { if (other == null) { return; } - if (other.HasDataPtr) { - DataPtr = other.DataPtr; - } - if (other.HasNumChannels) { - NumChannels = other.NumChannels; - } - if (other.HasSampleRate) { - SampleRate = other.SampleRate; + if (other.handle_ != null) { + if (handle_ == null) { + Handle = new global::LiveKit.Proto.FfiOwnedHandle(); + } + Handle.MergeFrom(other.Handle); } - if (other.HasSamplesPerChannel) { - SamplesPerChannel = other.SamplesPerChannel; + if (other.info_ != null) { + if (info_ == null) { + Info = new global::LiveKit.Proto.AudioStreamInfo(); + } + Info.MergeFrom(other.Info); } _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); } @@ -6440,23 +9744,21 @@ public void MergeFrom(pb::CodedInputStream input) { return; } switch(tag) { - default: - _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); - break; - case 8: { - DataPtr = input.ReadUInt64(); - break; - } - case 16: { - NumChannels = input.ReadUInt32(); + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); break; - } - case 24: { - SampleRate = input.ReadUInt32(); + case 10: { + if (handle_ == null) { + Handle = new global::LiveKit.Proto.FfiOwnedHandle(); + } + input.ReadMessage(Handle); break; } - case 32: { - SamplesPerChannel = input.ReadUInt32(); + case 18: { + if (info_ == null) { + Info = new global::LiveKit.Proto.AudioStreamInfo(); + } + input.ReadMessage(Info); break; } } @@ -6478,20 +9780,18 @@ public void MergeFrom(pb::CodedInputStream input) { default: _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); break; - case 8: { - DataPtr = input.ReadUInt64(); - break; - } - case 16: { - NumChannels = input.ReadUInt32(); - break; - } - case 24: { - SampleRate = input.ReadUInt32(); + case 10: { + if (handle_ == null) { + Handle = new global::LiveKit.Proto.FfiOwnedHandle(); + } + input.ReadMessage(Handle); break; } - case 32: { - SamplesPerChannel = input.ReadUInt32(); + case 18: { + if (info_ == null) { + Info = new global::LiveKit.Proto.AudioStreamInfo(); + } + input.ReadMessage(Info); break; } } @@ -6502,21 +9802,22 @@ public void MergeFrom(pb::CodedInputStream input) { } [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] - public sealed partial class OwnedAudioFrameBuffer : pb::IMessage + public sealed partial class AudioStreamEvent : pb::IMessage #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE , pb::IBufferMessage #endif { - private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new OwnedAudioFrameBuffer()); + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new AudioStreamEvent()); private pb::UnknownFieldSet _unknownFields; + private int _hasBits0; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public static pb::MessageParser Parser { get { return _parser; } } + public static pb::MessageParser Parser { get { return _parser; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::LiveKit.Proto.AudioFrameReflection.Descriptor.MessageTypes[22]; } + get { return global::LiveKit.Proto.AudioFrameReflection.Descriptor.MessageTypes[33]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -6527,7 +9828,7 @@ public sealed partial class OwnedAudioFrameBuffer : pb::IMessageField number for the "handle" field. - public const int HandleFieldNumber = 1; - private global::LiveKit.Proto.FfiOwnedHandle handle_; + /// Field number for the "stream_handle" field. + public const int StreamHandleFieldNumber = 1; + private readonly static ulong StreamHandleDefaultValue = 0UL; + + private ulong streamHandle_; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public global::LiveKit.Proto.FfiOwnedHandle Handle { - get { return handle_; } + public ulong StreamHandle { + get { if ((_hasBits0 & 1) != 0) { return streamHandle_; } else { return StreamHandleDefaultValue; } } set { - handle_ = value; + _hasBits0 |= 1; + streamHandle_ = value; + } + } + /// Gets whether the "stream_handle" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasStreamHandle { + get { return (_hasBits0 & 1) != 0; } + } + /// Clears the value of the "stream_handle" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearStreamHandle() { + _hasBits0 &= ~1; + } + + /// Field number for the "frame_received" field. + public const int FrameReceivedFieldNumber = 2; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.AudioFrameReceived FrameReceived { + get { return messageCase_ == MessageOneofCase.FrameReceived ? (global::LiveKit.Proto.AudioFrameReceived) message_ : null; } + set { + message_ = value; + messageCase_ = value == null ? MessageOneofCase.None : MessageOneofCase.FrameReceived; } } - /// Field number for the "info" field. - public const int InfoFieldNumber = 2; - private global::LiveKit.Proto.AudioFrameBufferInfo info_; + /// Field number for the "eos" field. + public const int EosFieldNumber = 3; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public global::LiveKit.Proto.AudioFrameBufferInfo Info { - get { return info_; } + public global::LiveKit.Proto.AudioStreamEOS Eos { + get { return messageCase_ == MessageOneofCase.Eos ? (global::LiveKit.Proto.AudioStreamEOS) message_ : null; } set { - info_ = value; + message_ = value; + messageCase_ = value == null ? MessageOneofCase.None : MessageOneofCase.Eos; } } + private object message_; + /// Enum of possible cases for the "message" oneof. + public enum MessageOneofCase { + None = 0, + FrameReceived = 2, + Eos = 3, + } + private MessageOneofCase messageCase_ = MessageOneofCase.None; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public MessageOneofCase MessageCase { + get { return messageCase_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearMessage() { + messageCase_ = MessageOneofCase.None; + message_ = null; + } + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override bool Equals(object other) { - return Equals(other as OwnedAudioFrameBuffer); + return Equals(other as AudioStreamEvent); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool Equals(OwnedAudioFrameBuffer other) { + public bool Equals(AudioStreamEvent other) { if (ReferenceEquals(other, null)) { return false; } if (ReferenceEquals(other, this)) { return true; } - if (!object.Equals(Handle, other.Handle)) return false; - if (!object.Equals(Info, other.Info)) return false; + if (StreamHandle != other.StreamHandle) return false; + if (!object.Equals(FrameReceived, other.FrameReceived)) return false; + if (!object.Equals(Eos, other.Eos)) return false; + if (MessageCase != other.MessageCase) return false; return Equals(_unknownFields, other._unknownFields); } @@ -6595,8 +9955,10 @@ public bool Equals(OwnedAudioFrameBuffer other) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override int GetHashCode() { int hash = 1; - if (handle_ != null) hash ^= Handle.GetHashCode(); - if (info_ != null) hash ^= Info.GetHashCode(); + if (HasStreamHandle) hash ^= StreamHandle.GetHashCode(); + if (messageCase_ == MessageOneofCase.FrameReceived) hash ^= FrameReceived.GetHashCode(); + if (messageCase_ == MessageOneofCase.Eos) hash ^= Eos.GetHashCode(); + hash ^= (int) messageCase_; if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } @@ -6615,13 +9977,17 @@ public void WriteTo(pb::CodedOutputStream output) { #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE output.WriteRawMessage(this); #else - if (handle_ != null) { - output.WriteRawTag(10); - output.WriteMessage(Handle); + if (HasStreamHandle) { + output.WriteRawTag(8); + output.WriteUInt64(StreamHandle); } - if (info_ != null) { + if (messageCase_ == MessageOneofCase.FrameReceived) { output.WriteRawTag(18); - output.WriteMessage(Info); + output.WriteMessage(FrameReceived); + } + if (messageCase_ == MessageOneofCase.Eos) { + output.WriteRawTag(26); + output.WriteMessage(Eos); } if (_unknownFields != null) { _unknownFields.WriteTo(output); @@ -6633,13 +9999,17 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { - if (handle_ != null) { - output.WriteRawTag(10); - output.WriteMessage(Handle); + if (HasStreamHandle) { + output.WriteRawTag(8); + output.WriteUInt64(StreamHandle); } - if (info_ != null) { + if (messageCase_ == MessageOneofCase.FrameReceived) { output.WriteRawTag(18); - output.WriteMessage(Info); + output.WriteMessage(FrameReceived); + } + if (messageCase_ == MessageOneofCase.Eos) { + output.WriteRawTag(26); + output.WriteMessage(Eos); } if (_unknownFields != null) { _unknownFields.WriteTo(ref output); @@ -6651,11 +10021,14 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public int CalculateSize() { int size = 0; - if (handle_ != null) { - size += 1 + pb::CodedOutputStream.ComputeMessageSize(Handle); + if (HasStreamHandle) { + size += 1 + pb::CodedOutputStream.ComputeUInt64Size(StreamHandle); } - if (info_ != null) { - size += 1 + pb::CodedOutputStream.ComputeMessageSize(Info); + if (messageCase_ == MessageOneofCase.FrameReceived) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(FrameReceived); + } + if (messageCase_ == MessageOneofCase.Eos) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Eos); } if (_unknownFields != null) { size += _unknownFields.CalculateSize(); @@ -6665,22 +10038,28 @@ public int CalculateSize() { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public void MergeFrom(OwnedAudioFrameBuffer other) { + public void MergeFrom(AudioStreamEvent other) { if (other == null) { return; } - if (other.handle_ != null) { - if (handle_ == null) { - Handle = new global::LiveKit.Proto.FfiOwnedHandle(); - } - Handle.MergeFrom(other.Handle); + if (other.HasStreamHandle) { + StreamHandle = other.StreamHandle; } - if (other.info_ != null) { - if (info_ == null) { - Info = new global::LiveKit.Proto.AudioFrameBufferInfo(); - } - Info.MergeFrom(other.Info); + switch (other.MessageCase) { + case MessageOneofCase.FrameReceived: + if (FrameReceived == null) { + FrameReceived = new global::LiveKit.Proto.AudioFrameReceived(); + } + FrameReceived.MergeFrom(other.FrameReceived); + break; + case MessageOneofCase.Eos: + if (Eos == null) { + Eos = new global::LiveKit.Proto.AudioStreamEOS(); + } + Eos.MergeFrom(other.Eos); + break; } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); } @@ -6700,18 +10079,26 @@ public void MergeFrom(pb::CodedInputStream input) { default: _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); break; - case 10: { - if (handle_ == null) { - Handle = new global::LiveKit.Proto.FfiOwnedHandle(); - } - input.ReadMessage(Handle); + case 8: { + StreamHandle = input.ReadUInt64(); break; } case 18: { - if (info_ == null) { - Info = new global::LiveKit.Proto.AudioFrameBufferInfo(); + global::LiveKit.Proto.AudioFrameReceived subBuilder = new global::LiveKit.Proto.AudioFrameReceived(); + if (messageCase_ == MessageOneofCase.FrameReceived) { + subBuilder.MergeFrom(FrameReceived); } - input.ReadMessage(Info); + input.ReadMessage(subBuilder); + FrameReceived = subBuilder; + break; + } + case 26: { + global::LiveKit.Proto.AudioStreamEOS subBuilder = new global::LiveKit.Proto.AudioStreamEOS(); + if (messageCase_ == MessageOneofCase.Eos) { + subBuilder.MergeFrom(Eos); + } + input.ReadMessage(subBuilder); + Eos = subBuilder; break; } } @@ -6733,18 +10120,26 @@ public void MergeFrom(pb::CodedInputStream input) { default: _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); break; - case 10: { - if (handle_ == null) { - Handle = new global::LiveKit.Proto.FfiOwnedHandle(); + case 8: { + StreamHandle = input.ReadUInt64(); + break; + } + case 18: { + global::LiveKit.Proto.AudioFrameReceived subBuilder = new global::LiveKit.Proto.AudioFrameReceived(); + if (messageCase_ == MessageOneofCase.FrameReceived) { + subBuilder.MergeFrom(FrameReceived); } - input.ReadMessage(Handle); + input.ReadMessage(subBuilder); + FrameReceived = subBuilder; break; } - case 18: { - if (info_ == null) { - Info = new global::LiveKit.Proto.AudioFrameBufferInfo(); + case 26: { + global::LiveKit.Proto.AudioStreamEOS subBuilder = new global::LiveKit.Proto.AudioStreamEOS(); + if (messageCase_ == MessageOneofCase.Eos) { + subBuilder.MergeFrom(Eos); } - input.ReadMessage(Info); + input.ReadMessage(subBuilder); + Eos = subBuilder; break; } } @@ -6755,22 +10150,21 @@ public void MergeFrom(pb::CodedInputStream input) { } [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] - public sealed partial class AudioStreamInfo : pb::IMessage + public sealed partial class AudioFrameReceived : pb::IMessage #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE , pb::IBufferMessage #endif { - private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new AudioStreamInfo()); + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new AudioFrameReceived()); private pb::UnknownFieldSet _unknownFields; - private int _hasBits0; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public static pb::MessageParser Parser { get { return _parser; } } + public static pb::MessageParser Parser { get { return _parser; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::LiveKit.Proto.AudioFrameReflection.Descriptor.MessageTypes[23]; } + get { return global::LiveKit.Proto.AudioFrameReflection.Descriptor.MessageTypes[34]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -6781,7 +10175,7 @@ public sealed partial class AudioStreamInfo : pb::IMessage [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public AudioStreamInfo() { + public AudioFrameReceived() { OnConstruction(); } @@ -6789,61 +10183,45 @@ public AudioStreamInfo() { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public AudioStreamInfo(AudioStreamInfo other) : this() { - _hasBits0 = other._hasBits0; - type_ = other.type_; + public AudioFrameReceived(AudioFrameReceived other) : this() { + frame_ = other.frame_ != null ? other.frame_.Clone() : null; _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public AudioStreamInfo Clone() { - return new AudioStreamInfo(this); + public AudioFrameReceived Clone() { + return new AudioFrameReceived(this); } - /// Field number for the "type" field. - public const int TypeFieldNumber = 1; - private readonly static global::LiveKit.Proto.AudioStreamType TypeDefaultValue = global::LiveKit.Proto.AudioStreamType.AudioStreamNative; - - private global::LiveKit.Proto.AudioStreamType type_; + /// Field number for the "frame" field. + public const int FrameFieldNumber = 1; + private global::LiveKit.Proto.OwnedAudioFrameBuffer frame_; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public global::LiveKit.Proto.AudioStreamType Type { - get { if ((_hasBits0 & 1) != 0) { return type_; } else { return TypeDefaultValue; } } + public global::LiveKit.Proto.OwnedAudioFrameBuffer Frame { + get { return frame_; } set { - _hasBits0 |= 1; - type_ = value; + frame_ = value; } } - /// Gets whether the "type" field is set - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool HasType { - get { return (_hasBits0 & 1) != 0; } - } - /// Clears the value of the "type" field - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public void ClearType() { - _hasBits0 &= ~1; - } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override bool Equals(object other) { - return Equals(other as AudioStreamInfo); + return Equals(other as AudioFrameReceived); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool Equals(AudioStreamInfo other) { + public bool Equals(AudioFrameReceived other) { if (ReferenceEquals(other, null)) { return false; } if (ReferenceEquals(other, this)) { return true; } - if (Type != other.Type) return false; + if (!object.Equals(Frame, other.Frame)) return false; return Equals(_unknownFields, other._unknownFields); } @@ -6851,7 +10229,7 @@ public bool Equals(AudioStreamInfo other) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override int GetHashCode() { int hash = 1; - if (HasType) hash ^= Type.GetHashCode(); + if (frame_ != null) hash ^= Frame.GetHashCode(); if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } @@ -6870,9 +10248,9 @@ public void WriteTo(pb::CodedOutputStream output) { #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE output.WriteRawMessage(this); #else - if (HasType) { - output.WriteRawTag(8); - output.WriteEnum((int) Type); + if (frame_ != null) { + output.WriteRawTag(10); + output.WriteMessage(Frame); } if (_unknownFields != null) { _unknownFields.WriteTo(output); @@ -6884,9 +10262,9 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { - if (HasType) { - output.WriteRawTag(8); - output.WriteEnum((int) Type); + if (frame_ != null) { + output.WriteRawTag(10); + output.WriteMessage(Frame); } if (_unknownFields != null) { _unknownFields.WriteTo(ref output); @@ -6898,8 +10276,8 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public int CalculateSize() { int size = 0; - if (HasType) { - size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) Type); + if (frame_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Frame); } if (_unknownFields != null) { size += _unknownFields.CalculateSize(); @@ -6909,12 +10287,15 @@ public int CalculateSize() { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public void MergeFrom(AudioStreamInfo other) { + public void MergeFrom(AudioFrameReceived other) { if (other == null) { return; } - if (other.HasType) { - Type = other.Type; + if (other.frame_ != null) { + if (frame_ == null) { + Frame = new global::LiveKit.Proto.OwnedAudioFrameBuffer(); + } + Frame.MergeFrom(other.Frame); } _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); } @@ -6935,8 +10316,11 @@ public void MergeFrom(pb::CodedInputStream input) { default: _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); break; - case 8: { - Type = (global::LiveKit.Proto.AudioStreamType) input.ReadEnum(); + case 10: { + if (frame_ == null) { + Frame = new global::LiveKit.Proto.OwnedAudioFrameBuffer(); + } + input.ReadMessage(Frame); break; } } @@ -6958,8 +10342,11 @@ public void MergeFrom(pb::CodedInputStream input) { default: _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); break; - case 8: { - Type = (global::LiveKit.Proto.AudioStreamType) input.ReadEnum(); + case 10: { + if (frame_ == null) { + Frame = new global::LiveKit.Proto.OwnedAudioFrameBuffer(); + } + input.ReadMessage(Frame); break; } } @@ -6970,21 +10357,21 @@ public void MergeFrom(pb::CodedInputStream input) { } [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] - public sealed partial class OwnedAudioStream : pb::IMessage + public sealed partial class AudioStreamEOS : pb::IMessage #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE , pb::IBufferMessage #endif { - private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new OwnedAudioStream()); + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new AudioStreamEOS()); private pb::UnknownFieldSet _unknownFields; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public static pb::MessageParser Parser { get { return _parser; } } + public static pb::MessageParser Parser { get { return _parser; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::LiveKit.Proto.AudioFrameReflection.Descriptor.MessageTypes[24]; } + get { return global::LiveKit.Proto.AudioFrameReflection.Descriptor.MessageTypes[35]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -6995,7 +10382,7 @@ public sealed partial class OwnedAudioStream : pb::IMessage [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public OwnedAudioStream() { + public AudioStreamEOS() { OnConstruction(); } @@ -7003,59 +10390,31 @@ public OwnedAudioStream() { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public OwnedAudioStream(OwnedAudioStream other) : this() { - handle_ = other.handle_ != null ? other.handle_.Clone() : null; - info_ = other.info_ != null ? other.info_.Clone() : null; + public AudioStreamEOS(AudioStreamEOS other) : this() { _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public OwnedAudioStream Clone() { - return new OwnedAudioStream(this); - } - - /// Field number for the "handle" field. - public const int HandleFieldNumber = 1; - private global::LiveKit.Proto.FfiOwnedHandle handle_; - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public global::LiveKit.Proto.FfiOwnedHandle Handle { - get { return handle_; } - set { - handle_ = value; - } - } - - /// Field number for the "info" field. - public const int InfoFieldNumber = 2; - private global::LiveKit.Proto.AudioStreamInfo info_; - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public global::LiveKit.Proto.AudioStreamInfo Info { - get { return info_; } - set { - info_ = value; - } + public AudioStreamEOS Clone() { + return new AudioStreamEOS(this); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override bool Equals(object other) { - return Equals(other as OwnedAudioStream); + return Equals(other as AudioStreamEOS); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool Equals(OwnedAudioStream other) { + public bool Equals(AudioStreamEOS other) { if (ReferenceEquals(other, null)) { return false; } if (ReferenceEquals(other, this)) { return true; } - if (!object.Equals(Handle, other.Handle)) return false; - if (!object.Equals(Info, other.Info)) return false; return Equals(_unknownFields, other._unknownFields); } @@ -7063,8 +10422,6 @@ public bool Equals(OwnedAudioStream other) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override int GetHashCode() { int hash = 1; - if (handle_ != null) hash ^= Handle.GetHashCode(); - if (info_ != null) hash ^= Info.GetHashCode(); if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } @@ -7083,14 +10440,6 @@ public void WriteTo(pb::CodedOutputStream output) { #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE output.WriteRawMessage(this); #else - if (handle_ != null) { - output.WriteRawTag(10); - output.WriteMessage(Handle); - } - if (info_ != null) { - output.WriteRawTag(18); - output.WriteMessage(Info); - } if (_unknownFields != null) { _unknownFields.WriteTo(output); } @@ -7101,14 +10450,6 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { - if (handle_ != null) { - output.WriteRawTag(10); - output.WriteMessage(Handle); - } - if (info_ != null) { - output.WriteRawTag(18); - output.WriteMessage(Info); - } if (_unknownFields != null) { _unknownFields.WriteTo(ref output); } @@ -7119,12 +10460,6 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public int CalculateSize() { int size = 0; - if (handle_ != null) { - size += 1 + pb::CodedOutputStream.ComputeMessageSize(Handle); - } - if (info_ != null) { - size += 1 + pb::CodedOutputStream.ComputeMessageSize(Info); - } if (_unknownFields != null) { size += _unknownFields.CalculateSize(); } @@ -7133,22 +10468,10 @@ public int CalculateSize() { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public void MergeFrom(OwnedAudioStream other) { + public void MergeFrom(AudioStreamEOS other) { if (other == null) { return; } - if (other.handle_ != null) { - if (handle_ == null) { - Handle = new global::LiveKit.Proto.FfiOwnedHandle(); - } - Handle.MergeFrom(other.Handle); - } - if (other.info_ != null) { - if (info_ == null) { - Info = new global::LiveKit.Proto.AudioStreamInfo(); - } - Info.MergeFrom(other.Info); - } _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); } @@ -7168,20 +10491,6 @@ public void MergeFrom(pb::CodedInputStream input) { default: _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); break; - case 10: { - if (handle_ == null) { - Handle = new global::LiveKit.Proto.FfiOwnedHandle(); - } - input.ReadMessage(Handle); - break; - } - case 18: { - if (info_ == null) { - Info = new global::LiveKit.Proto.AudioStreamInfo(); - } - input.ReadMessage(Info); - break; - } } } #endif @@ -7201,20 +10510,6 @@ public void MergeFrom(pb::CodedInputStream input) { default: _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); break; - case 10: { - if (handle_ == null) { - Handle = new global::LiveKit.Proto.FfiOwnedHandle(); - } - input.ReadMessage(Handle); - break; - } - case 18: { - if (info_ == null) { - Info = new global::LiveKit.Proto.AudioStreamInfo(); - } - input.ReadMessage(Info); - break; - } } } } @@ -7223,22 +10518,22 @@ public void MergeFrom(pb::CodedInputStream input) { } [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] - public sealed partial class AudioStreamEvent : pb::IMessage + public sealed partial class AudioSourceOptions : pb::IMessage #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE , pb::IBufferMessage #endif { - private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new AudioStreamEvent()); + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new AudioSourceOptions()); private pb::UnknownFieldSet _unknownFields; private int _hasBits0; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public static pb::MessageParser Parser { get { return _parser; } } + public static pb::MessageParser Parser { get { return _parser; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::LiveKit.Proto.AudioFrameReflection.Descriptor.MessageTypes[25]; } + get { return global::LiveKit.Proto.AudioFrameReflection.Descriptor.MessageTypes[36]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -7249,7 +10544,7 @@ public sealed partial class AudioStreamEvent : pb::IMessage [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public AudioStreamEvent() { + public AudioSourceOptions() { OnConstruction(); } @@ -7257,118 +10552,119 @@ public AudioStreamEvent() { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public AudioStreamEvent(AudioStreamEvent other) : this() { + public AudioSourceOptions(AudioSourceOptions other) : this() { _hasBits0 = other._hasBits0; - streamHandle_ = other.streamHandle_; - switch (other.MessageCase) { - case MessageOneofCase.FrameReceived: - FrameReceived = other.FrameReceived.Clone(); - break; - case MessageOneofCase.Eos: - Eos = other.Eos.Clone(); - break; - } - + echoCancellation_ = other.echoCancellation_; + noiseSuppression_ = other.noiseSuppression_; + autoGainControl_ = other.autoGainControl_; _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public AudioStreamEvent Clone() { - return new AudioStreamEvent(this); + public AudioSourceOptions Clone() { + return new AudioSourceOptions(this); } - /// Field number for the "stream_handle" field. - public const int StreamHandleFieldNumber = 1; - private readonly static ulong StreamHandleDefaultValue = 0UL; + /// Field number for the "echo_cancellation" field. + public const int EchoCancellationFieldNumber = 1; + private readonly static bool EchoCancellationDefaultValue = false; - private ulong streamHandle_; + private bool echoCancellation_; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public ulong StreamHandle { - get { if ((_hasBits0 & 1) != 0) { return streamHandle_; } else { return StreamHandleDefaultValue; } } + public bool EchoCancellation { + get { if ((_hasBits0 & 1) != 0) { return echoCancellation_; } else { return EchoCancellationDefaultValue; } } set { _hasBits0 |= 1; - streamHandle_ = value; + echoCancellation_ = value; } } - /// Gets whether the "stream_handle" field is set + /// Gets whether the "echo_cancellation" field is set [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool HasStreamHandle { + public bool HasEchoCancellation { get { return (_hasBits0 & 1) != 0; } } - /// Clears the value of the "stream_handle" field + /// Clears the value of the "echo_cancellation" field [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public void ClearStreamHandle() { + public void ClearEchoCancellation() { _hasBits0 &= ~1; } - /// Field number for the "frame_received" field. - public const int FrameReceivedFieldNumber = 2; + /// Field number for the "noise_suppression" field. + public const int NoiseSuppressionFieldNumber = 2; + private readonly static bool NoiseSuppressionDefaultValue = false; + + private bool noiseSuppression_; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public global::LiveKit.Proto.AudioFrameReceived FrameReceived { - get { return messageCase_ == MessageOneofCase.FrameReceived ? (global::LiveKit.Proto.AudioFrameReceived) message_ : null; } + public bool NoiseSuppression { + get { if ((_hasBits0 & 2) != 0) { return noiseSuppression_; } else { return NoiseSuppressionDefaultValue; } } set { - message_ = value; - messageCase_ = value == null ? MessageOneofCase.None : MessageOneofCase.FrameReceived; + _hasBits0 |= 2; + noiseSuppression_ = value; } } + /// Gets whether the "noise_suppression" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasNoiseSuppression { + get { return (_hasBits0 & 2) != 0; } + } + /// Clears the value of the "noise_suppression" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearNoiseSuppression() { + _hasBits0 &= ~2; + } - /// Field number for the "eos" field. - public const int EosFieldNumber = 3; + /// Field number for the "auto_gain_control" field. + public const int AutoGainControlFieldNumber = 3; + private readonly static bool AutoGainControlDefaultValue = false; + + private bool autoGainControl_; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public global::LiveKit.Proto.AudioStreamEOS Eos { - get { return messageCase_ == MessageOneofCase.Eos ? (global::LiveKit.Proto.AudioStreamEOS) message_ : null; } + public bool AutoGainControl { + get { if ((_hasBits0 & 4) != 0) { return autoGainControl_; } else { return AutoGainControlDefaultValue; } } set { - message_ = value; - messageCase_ = value == null ? MessageOneofCase.None : MessageOneofCase.Eos; + _hasBits0 |= 4; + autoGainControl_ = value; } } - - private object message_; - /// Enum of possible cases for the "message" oneof. - public enum MessageOneofCase { - None = 0, - FrameReceived = 2, - Eos = 3, - } - private MessageOneofCase messageCase_ = MessageOneofCase.None; + /// Gets whether the "auto_gain_control" field is set [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public MessageOneofCase MessageCase { - get { return messageCase_; } + public bool HasAutoGainControl { + get { return (_hasBits0 & 4) != 0; } } - + /// Clears the value of the "auto_gain_control" field [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public void ClearMessage() { - messageCase_ = MessageOneofCase.None; - message_ = null; + public void ClearAutoGainControl() { + _hasBits0 &= ~4; } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override bool Equals(object other) { - return Equals(other as AudioStreamEvent); + return Equals(other as AudioSourceOptions); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool Equals(AudioStreamEvent other) { + public bool Equals(AudioSourceOptions other) { if (ReferenceEquals(other, null)) { return false; } if (ReferenceEquals(other, this)) { return true; } - if (StreamHandle != other.StreamHandle) return false; - if (!object.Equals(FrameReceived, other.FrameReceived)) return false; - if (!object.Equals(Eos, other.Eos)) return false; - if (MessageCase != other.MessageCase) return false; + if (EchoCancellation != other.EchoCancellation) return false; + if (NoiseSuppression != other.NoiseSuppression) return false; + if (AutoGainControl != other.AutoGainControl) return false; return Equals(_unknownFields, other._unknownFields); } @@ -7376,10 +10672,9 @@ public bool Equals(AudioStreamEvent other) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override int GetHashCode() { int hash = 1; - if (HasStreamHandle) hash ^= StreamHandle.GetHashCode(); - if (messageCase_ == MessageOneofCase.FrameReceived) hash ^= FrameReceived.GetHashCode(); - if (messageCase_ == MessageOneofCase.Eos) hash ^= Eos.GetHashCode(); - hash ^= (int) messageCase_; + if (HasEchoCancellation) hash ^= EchoCancellation.GetHashCode(); + if (HasNoiseSuppression) hash ^= NoiseSuppression.GetHashCode(); + if (HasAutoGainControl) hash ^= AutoGainControl.GetHashCode(); if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } @@ -7398,17 +10693,17 @@ public void WriteTo(pb::CodedOutputStream output) { #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE output.WriteRawMessage(this); #else - if (HasStreamHandle) { + if (HasEchoCancellation) { output.WriteRawTag(8); - output.WriteUInt64(StreamHandle); + output.WriteBool(EchoCancellation); } - if (messageCase_ == MessageOneofCase.FrameReceived) { - output.WriteRawTag(18); - output.WriteMessage(FrameReceived); + if (HasNoiseSuppression) { + output.WriteRawTag(16); + output.WriteBool(NoiseSuppression); } - if (messageCase_ == MessageOneofCase.Eos) { - output.WriteRawTag(26); - output.WriteMessage(Eos); + if (HasAutoGainControl) { + output.WriteRawTag(24); + output.WriteBool(AutoGainControl); } if (_unknownFields != null) { _unknownFields.WriteTo(output); @@ -7420,17 +10715,17 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { - if (HasStreamHandle) { + if (HasEchoCancellation) { output.WriteRawTag(8); - output.WriteUInt64(StreamHandle); + output.WriteBool(EchoCancellation); } - if (messageCase_ == MessageOneofCase.FrameReceived) { - output.WriteRawTag(18); - output.WriteMessage(FrameReceived); + if (HasNoiseSuppression) { + output.WriteRawTag(16); + output.WriteBool(NoiseSuppression); } - if (messageCase_ == MessageOneofCase.Eos) { - output.WriteRawTag(26); - output.WriteMessage(Eos); + if (HasAutoGainControl) { + output.WriteRawTag(24); + output.WriteBool(AutoGainControl); } if (_unknownFields != null) { _unknownFields.WriteTo(ref output); @@ -7442,14 +10737,14 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public int CalculateSize() { int size = 0; - if (HasStreamHandle) { - size += 1 + pb::CodedOutputStream.ComputeUInt64Size(StreamHandle); + if (HasEchoCancellation) { + size += 1 + 1; } - if (messageCase_ == MessageOneofCase.FrameReceived) { - size += 1 + pb::CodedOutputStream.ComputeMessageSize(FrameReceived); + if (HasNoiseSuppression) { + size += 1 + 1; } - if (messageCase_ == MessageOneofCase.Eos) { - size += 1 + pb::CodedOutputStream.ComputeMessageSize(Eos); + if (HasAutoGainControl) { + size += 1 + 1; } if (_unknownFields != null) { size += _unknownFields.CalculateSize(); @@ -7459,28 +10754,19 @@ public int CalculateSize() { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public void MergeFrom(AudioStreamEvent other) { + public void MergeFrom(AudioSourceOptions other) { if (other == null) { return; } - if (other.HasStreamHandle) { - StreamHandle = other.StreamHandle; + if (other.HasEchoCancellation) { + EchoCancellation = other.EchoCancellation; } - switch (other.MessageCase) { - case MessageOneofCase.FrameReceived: - if (FrameReceived == null) { - FrameReceived = new global::LiveKit.Proto.AudioFrameReceived(); - } - FrameReceived.MergeFrom(other.FrameReceived); - break; - case MessageOneofCase.Eos: - if (Eos == null) { - Eos = new global::LiveKit.Proto.AudioStreamEOS(); - } - Eos.MergeFrom(other.Eos); - break; + if (other.HasNoiseSuppression) { + NoiseSuppression = other.NoiseSuppression; + } + if (other.HasAutoGainControl) { + AutoGainControl = other.AutoGainControl; } - _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); } @@ -7501,25 +10787,15 @@ public void MergeFrom(pb::CodedInputStream input) { _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); break; case 8: { - StreamHandle = input.ReadUInt64(); + EchoCancellation = input.ReadBool(); break; } - case 18: { - global::LiveKit.Proto.AudioFrameReceived subBuilder = new global::LiveKit.Proto.AudioFrameReceived(); - if (messageCase_ == MessageOneofCase.FrameReceived) { - subBuilder.MergeFrom(FrameReceived); - } - input.ReadMessage(subBuilder); - FrameReceived = subBuilder; + case 16: { + NoiseSuppression = input.ReadBool(); break; } - case 26: { - global::LiveKit.Proto.AudioStreamEOS subBuilder = new global::LiveKit.Proto.AudioStreamEOS(); - if (messageCase_ == MessageOneofCase.Eos) { - subBuilder.MergeFrom(Eos); - } - input.ReadMessage(subBuilder); - Eos = subBuilder; + case 24: { + AutoGainControl = input.ReadBool(); break; } } @@ -7542,25 +10818,15 @@ public void MergeFrom(pb::CodedInputStream input) { _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); break; case 8: { - StreamHandle = input.ReadUInt64(); + EchoCancellation = input.ReadBool(); break; } - case 18: { - global::LiveKit.Proto.AudioFrameReceived subBuilder = new global::LiveKit.Proto.AudioFrameReceived(); - if (messageCase_ == MessageOneofCase.FrameReceived) { - subBuilder.MergeFrom(FrameReceived); - } - input.ReadMessage(subBuilder); - FrameReceived = subBuilder; + case 16: { + NoiseSuppression = input.ReadBool(); break; } - case 26: { - global::LiveKit.Proto.AudioStreamEOS subBuilder = new global::LiveKit.Proto.AudioStreamEOS(); - if (messageCase_ == MessageOneofCase.Eos) { - subBuilder.MergeFrom(Eos); - } - input.ReadMessage(subBuilder); - Eos = subBuilder; + case 24: { + AutoGainControl = input.ReadBool(); break; } } @@ -7571,21 +10837,22 @@ public void MergeFrom(pb::CodedInputStream input) { } [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] - public sealed partial class AudioFrameReceived : pb::IMessage + public sealed partial class AudioSourceInfo : pb::IMessage #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE , pb::IBufferMessage #endif { - private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new AudioFrameReceived()); + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new AudioSourceInfo()); private pb::UnknownFieldSet _unknownFields; + private int _hasBits0; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public static pb::MessageParser Parser { get { return _parser; } } + public static pb::MessageParser Parser { get { return _parser; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::LiveKit.Proto.AudioFrameReflection.Descriptor.MessageTypes[26]; } + get { return global::LiveKit.Proto.AudioFrameReflection.Descriptor.MessageTypes[37]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -7596,7 +10863,7 @@ public sealed partial class AudioFrameReceived : pb::IMessageField number for the "frame" field. - public const int FrameFieldNumber = 1; - private global::LiveKit.Proto.OwnedAudioFrameBuffer frame_; + /// Field number for the "type" field. + public const int TypeFieldNumber = 2; + private readonly static global::LiveKit.Proto.AudioSourceType TypeDefaultValue = global::LiveKit.Proto.AudioSourceType.AudioSourceNative; + + private global::LiveKit.Proto.AudioSourceType type_; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public global::LiveKit.Proto.OwnedAudioFrameBuffer Frame { - get { return frame_; } + public global::LiveKit.Proto.AudioSourceType Type { + get { if ((_hasBits0 & 1) != 0) { return type_; } else { return TypeDefaultValue; } } set { - frame_ = value; + _hasBits0 |= 1; + type_ = value; } } + /// Gets whether the "type" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasType { + get { return (_hasBits0 & 1) != 0; } + } + /// Clears the value of the "type" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearType() { + _hasBits0 &= ~1; + } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override bool Equals(object other) { - return Equals(other as AudioFrameReceived); + return Equals(other as AudioSourceInfo); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool Equals(AudioFrameReceived other) { + public bool Equals(AudioSourceInfo other) { if (ReferenceEquals(other, null)) { return false; } if (ReferenceEquals(other, this)) { return true; } - if (!object.Equals(Frame, other.Frame)) return false; + if (Type != other.Type) return false; return Equals(_unknownFields, other._unknownFields); } @@ -7650,7 +10933,7 @@ public bool Equals(AudioFrameReceived other) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override int GetHashCode() { int hash = 1; - if (frame_ != null) hash ^= Frame.GetHashCode(); + if (HasType) hash ^= Type.GetHashCode(); if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } @@ -7669,9 +10952,9 @@ public void WriteTo(pb::CodedOutputStream output) { #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE output.WriteRawMessage(this); #else - if (frame_ != null) { - output.WriteRawTag(10); - output.WriteMessage(Frame); + if (HasType) { + output.WriteRawTag(16); + output.WriteEnum((int) Type); } if (_unknownFields != null) { _unknownFields.WriteTo(output); @@ -7683,9 +10966,9 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { - if (frame_ != null) { - output.WriteRawTag(10); - output.WriteMessage(Frame); + if (HasType) { + output.WriteRawTag(16); + output.WriteEnum((int) Type); } if (_unknownFields != null) { _unknownFields.WriteTo(ref output); @@ -7697,8 +10980,8 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public int CalculateSize() { int size = 0; - if (frame_ != null) { - size += 1 + pb::CodedOutputStream.ComputeMessageSize(Frame); + if (HasType) { + size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) Type); } if (_unknownFields != null) { size += _unknownFields.CalculateSize(); @@ -7708,15 +10991,12 @@ public int CalculateSize() { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public void MergeFrom(AudioFrameReceived other) { + public void MergeFrom(AudioSourceInfo other) { if (other == null) { return; } - if (other.frame_ != null) { - if (frame_ == null) { - Frame = new global::LiveKit.Proto.OwnedAudioFrameBuffer(); - } - Frame.MergeFrom(other.Frame); + if (other.HasType) { + Type = other.Type; } _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); } @@ -7737,11 +11017,8 @@ public void MergeFrom(pb::CodedInputStream input) { default: _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); break; - case 10: { - if (frame_ == null) { - Frame = new global::LiveKit.Proto.OwnedAudioFrameBuffer(); - } - input.ReadMessage(Frame); + case 16: { + Type = (global::LiveKit.Proto.AudioSourceType) input.ReadEnum(); break; } } @@ -7763,11 +11040,8 @@ public void MergeFrom(pb::CodedInputStream input) { default: _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); break; - case 10: { - if (frame_ == null) { - Frame = new global::LiveKit.Proto.OwnedAudioFrameBuffer(); - } - input.ReadMessage(Frame); + case 16: { + Type = (global::LiveKit.Proto.AudioSourceType) input.ReadEnum(); break; } } @@ -7778,21 +11052,21 @@ public void MergeFrom(pb::CodedInputStream input) { } [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] - public sealed partial class AudioStreamEOS : pb::IMessage + public sealed partial class OwnedAudioSource : pb::IMessage #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE , pb::IBufferMessage #endif { - private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new AudioStreamEOS()); + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new OwnedAudioSource()); private pb::UnknownFieldSet _unknownFields; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public static pb::MessageParser Parser { get { return _parser; } } + public static pb::MessageParser Parser { get { return _parser; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::LiveKit.Proto.AudioFrameReflection.Descriptor.MessageTypes[27]; } + get { return global::LiveKit.Proto.AudioFrameReflection.Descriptor.MessageTypes[38]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -7803,7 +11077,7 @@ public sealed partial class AudioStreamEOS : pb::IMessage [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public AudioStreamEOS() { + public OwnedAudioSource() { OnConstruction(); } @@ -7811,31 +11085,59 @@ public AudioStreamEOS() { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public AudioStreamEOS(AudioStreamEOS other) : this() { + public OwnedAudioSource(OwnedAudioSource other) : this() { + handle_ = other.handle_ != null ? other.handle_.Clone() : null; + info_ = other.info_ != null ? other.info_.Clone() : null; _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public AudioStreamEOS Clone() { - return new AudioStreamEOS(this); + public OwnedAudioSource Clone() { + return new OwnedAudioSource(this); + } + + /// Field number for the "handle" field. + public const int HandleFieldNumber = 1; + private global::LiveKit.Proto.FfiOwnedHandle handle_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.FfiOwnedHandle Handle { + get { return handle_; } + set { + handle_ = value; + } + } + + /// Field number for the "info" field. + public const int InfoFieldNumber = 2; + private global::LiveKit.Proto.AudioSourceInfo info_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.AudioSourceInfo Info { + get { return info_; } + set { + info_ = value; + } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override bool Equals(object other) { - return Equals(other as AudioStreamEOS); + return Equals(other as OwnedAudioSource); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool Equals(AudioStreamEOS other) { + public bool Equals(OwnedAudioSource other) { if (ReferenceEquals(other, null)) { return false; } if (ReferenceEquals(other, this)) { return true; } + if (!object.Equals(Handle, other.Handle)) return false; + if (!object.Equals(Info, other.Info)) return false; return Equals(_unknownFields, other._unknownFields); } @@ -7843,6 +11145,8 @@ public bool Equals(AudioStreamEOS other) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override int GetHashCode() { int hash = 1; + if (handle_ != null) hash ^= Handle.GetHashCode(); + if (info_ != null) hash ^= Info.GetHashCode(); if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } @@ -7861,6 +11165,14 @@ public void WriteTo(pb::CodedOutputStream output) { #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE output.WriteRawMessage(this); #else + if (handle_ != null) { + output.WriteRawTag(10); + output.WriteMessage(Handle); + } + if (info_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Info); + } if (_unknownFields != null) { _unknownFields.WriteTo(output); } @@ -7871,6 +11183,14 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (handle_ != null) { + output.WriteRawTag(10); + output.WriteMessage(Handle); + } + if (info_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Info); + } if (_unknownFields != null) { _unknownFields.WriteTo(ref output); } @@ -7881,6 +11201,12 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public int CalculateSize() { int size = 0; + if (handle_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Handle); + } + if (info_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Info); + } if (_unknownFields != null) { size += _unknownFields.CalculateSize(); } @@ -7889,10 +11215,22 @@ public int CalculateSize() { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public void MergeFrom(AudioStreamEOS other) { + public void MergeFrom(OwnedAudioSource other) { if (other == null) { return; } + if (other.handle_ != null) { + if (handle_ == null) { + Handle = new global::LiveKit.Proto.FfiOwnedHandle(); + } + Handle.MergeFrom(other.Handle); + } + if (other.info_ != null) { + if (info_ == null) { + Info = new global::LiveKit.Proto.AudioSourceInfo(); + } + Info.MergeFrom(other.Info); + } _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); } @@ -7912,6 +11250,20 @@ public void MergeFrom(pb::CodedInputStream input) { default: _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); break; + case 10: { + if (handle_ == null) { + Handle = new global::LiveKit.Proto.FfiOwnedHandle(); + } + input.ReadMessage(Handle); + break; + } + case 18: { + if (info_ == null) { + Info = new global::LiveKit.Proto.AudioSourceInfo(); + } + input.ReadMessage(Info); + break; + } } } #endif @@ -7931,6 +11283,20 @@ public void MergeFrom(pb::CodedInputStream input) { default: _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); break; + case 10: { + if (handle_ == null) { + Handle = new global::LiveKit.Proto.FfiOwnedHandle(); + } + input.ReadMessage(Handle); + break; + } + case 18: { + if (info_ == null) { + Info = new global::LiveKit.Proto.AudioSourceInfo(); + } + input.ReadMessage(Info); + break; + } } } } @@ -7939,22 +11305,21 @@ public void MergeFrom(pb::CodedInputStream input) { } [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] - public sealed partial class AudioSourceOptions : pb::IMessage + public sealed partial class AudioResamplerInfo : pb::IMessage #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE , pb::IBufferMessage #endif { - private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new AudioSourceOptions()); + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new AudioResamplerInfo()); private pb::UnknownFieldSet _unknownFields; - private int _hasBits0; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public static pb::MessageParser Parser { get { return _parser; } } + public static pb::MessageParser Parser { get { return _parser; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::LiveKit.Proto.AudioFrameReflection.Descriptor.MessageTypes[28]; } + get { return global::LiveKit.Proto.AudioFrameReflection.Descriptor.MessageTypes[39]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -7965,7 +11330,7 @@ public sealed partial class AudioSourceOptions : pb::IMessageField number for the "echo_cancellation" field. - public const int EchoCancellationFieldNumber = 1; - private readonly static bool EchoCancellationDefaultValue = false; - - private bool echoCancellation_; - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool EchoCancellation { - get { if ((_hasBits0 & 1) != 0) { return echoCancellation_; } else { return EchoCancellationDefaultValue; } } - set { - _hasBits0 |= 1; - echoCancellation_ = value; - } - } - /// Gets whether the "echo_cancellation" field is set - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool HasEchoCancellation { - get { return (_hasBits0 & 1) != 0; } - } - /// Clears the value of the "echo_cancellation" field - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public void ClearEchoCancellation() { - _hasBits0 &= ~1; - } - - /// Field number for the "noise_suppression" field. - public const int NoiseSuppressionFieldNumber = 2; - private readonly static bool NoiseSuppressionDefaultValue = false; - - private bool noiseSuppression_; - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool NoiseSuppression { - get { if ((_hasBits0 & 2) != 0) { return noiseSuppression_; } else { return NoiseSuppressionDefaultValue; } } - set { - _hasBits0 |= 2; - noiseSuppression_ = value; - } - } - /// Gets whether the "noise_suppression" field is set - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool HasNoiseSuppression { - get { return (_hasBits0 & 2) != 0; } - } - /// Clears the value of the "noise_suppression" field - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public void ClearNoiseSuppression() { - _hasBits0 &= ~2; - } - - /// Field number for the "auto_gain_control" field. - public const int AutoGainControlFieldNumber = 3; - private readonly static bool AutoGainControlDefaultValue = false; - - private bool autoGainControl_; - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool AutoGainControl { - get { if ((_hasBits0 & 4) != 0) { return autoGainControl_; } else { return AutoGainControlDefaultValue; } } - set { - _hasBits0 |= 4; - autoGainControl_ = value; - } - } - /// Gets whether the "auto_gain_control" field is set - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool HasAutoGainControl { - get { return (_hasBits0 & 4) != 0; } - } - /// Clears the value of the "auto_gain_control" field - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public void ClearAutoGainControl() { - _hasBits0 &= ~4; + public AudioResamplerInfo Clone() { + return new AudioResamplerInfo(this); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override bool Equals(object other) { - return Equals(other as AudioSourceOptions); + return Equals(other as AudioResamplerInfo); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool Equals(AudioSourceOptions other) { + public bool Equals(AudioResamplerInfo other) { if (ReferenceEquals(other, null)) { return false; } if (ReferenceEquals(other, this)) { return true; } - if (EchoCancellation != other.EchoCancellation) return false; - if (NoiseSuppression != other.NoiseSuppression) return false; - if (AutoGainControl != other.AutoGainControl) return false; return Equals(_unknownFields, other._unknownFields); } @@ -8093,9 +11370,6 @@ public bool Equals(AudioSourceOptions other) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override int GetHashCode() { int hash = 1; - if (HasEchoCancellation) hash ^= EchoCancellation.GetHashCode(); - if (HasNoiseSuppression) hash ^= NoiseSuppression.GetHashCode(); - if (HasAutoGainControl) hash ^= AutoGainControl.GetHashCode(); if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } @@ -8114,18 +11388,6 @@ public void WriteTo(pb::CodedOutputStream output) { #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE output.WriteRawMessage(this); #else - if (HasEchoCancellation) { - output.WriteRawTag(8); - output.WriteBool(EchoCancellation); - } - if (HasNoiseSuppression) { - output.WriteRawTag(16); - output.WriteBool(NoiseSuppression); - } - if (HasAutoGainControl) { - output.WriteRawTag(24); - output.WriteBool(AutoGainControl); - } if (_unknownFields != null) { _unknownFields.WriteTo(output); } @@ -8136,18 +11398,6 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { - if (HasEchoCancellation) { - output.WriteRawTag(8); - output.WriteBool(EchoCancellation); - } - if (HasNoiseSuppression) { - output.WriteRawTag(16); - output.WriteBool(NoiseSuppression); - } - if (HasAutoGainControl) { - output.WriteRawTag(24); - output.WriteBool(AutoGainControl); - } if (_unknownFields != null) { _unknownFields.WriteTo(ref output); } @@ -8158,15 +11408,6 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public int CalculateSize() { int size = 0; - if (HasEchoCancellation) { - size += 1 + 1; - } - if (HasNoiseSuppression) { - size += 1 + 1; - } - if (HasAutoGainControl) { - size += 1 + 1; - } if (_unknownFields != null) { size += _unknownFields.CalculateSize(); } @@ -8175,19 +11416,10 @@ public int CalculateSize() { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public void MergeFrom(AudioSourceOptions other) { + public void MergeFrom(AudioResamplerInfo other) { if (other == null) { return; } - if (other.HasEchoCancellation) { - EchoCancellation = other.EchoCancellation; - } - if (other.HasNoiseSuppression) { - NoiseSuppression = other.NoiseSuppression; - } - if (other.HasAutoGainControl) { - AutoGainControl = other.AutoGainControl; - } _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); } @@ -8207,18 +11439,6 @@ public void MergeFrom(pb::CodedInputStream input) { default: _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); break; - case 8: { - EchoCancellation = input.ReadBool(); - break; - } - case 16: { - NoiseSuppression = input.ReadBool(); - break; - } - case 24: { - AutoGainControl = input.ReadBool(); - break; - } } } #endif @@ -8238,18 +11458,6 @@ public void MergeFrom(pb::CodedInputStream input) { default: _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); break; - case 8: { - EchoCancellation = input.ReadBool(); - break; - } - case 16: { - NoiseSuppression = input.ReadBool(); - break; - } - case 24: { - AutoGainControl = input.ReadBool(); - break; - } } } } @@ -8258,22 +11466,21 @@ public void MergeFrom(pb::CodedInputStream input) { } [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] - public sealed partial class AudioSourceInfo : pb::IMessage + public sealed partial class OwnedAudioResampler : pb::IMessage #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE , pb::IBufferMessage #endif { - private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new AudioSourceInfo()); + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new OwnedAudioResampler()); private pb::UnknownFieldSet _unknownFields; - private int _hasBits0; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public static pb::MessageParser Parser { get { return _parser; } } + public static pb::MessageParser Parser { get { return _parser; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::LiveKit.Proto.AudioFrameReflection.Descriptor.MessageTypes[29]; } + get { return global::LiveKit.Proto.AudioFrameReflection.Descriptor.MessageTypes[40]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -8284,7 +11491,7 @@ public sealed partial class AudioSourceInfo : pb::IMessage [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public AudioSourceInfo() { + public OwnedAudioResampler() { OnConstruction(); } @@ -8292,61 +11499,59 @@ public AudioSourceInfo() { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public AudioSourceInfo(AudioSourceInfo other) : this() { - _hasBits0 = other._hasBits0; - type_ = other.type_; + public OwnedAudioResampler(OwnedAudioResampler other) : this() { + handle_ = other.handle_ != null ? other.handle_.Clone() : null; + info_ = other.info_ != null ? other.info_.Clone() : null; _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public AudioSourceInfo Clone() { - return new AudioSourceInfo(this); + public OwnedAudioResampler Clone() { + return new OwnedAudioResampler(this); } - /// Field number for the "type" field. - public const int TypeFieldNumber = 2; - private readonly static global::LiveKit.Proto.AudioSourceType TypeDefaultValue = global::LiveKit.Proto.AudioSourceType.AudioSourceNative; - - private global::LiveKit.Proto.AudioSourceType type_; + /// Field number for the "handle" field. + public const int HandleFieldNumber = 1; + private global::LiveKit.Proto.FfiOwnedHandle handle_; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public global::LiveKit.Proto.AudioSourceType Type { - get { if ((_hasBits0 & 1) != 0) { return type_; } else { return TypeDefaultValue; } } + public global::LiveKit.Proto.FfiOwnedHandle Handle { + get { return handle_; } set { - _hasBits0 |= 1; - type_ = value; + handle_ = value; } } - /// Gets whether the "type" field is set - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool HasType { - get { return (_hasBits0 & 1) != 0; } - } - /// Clears the value of the "type" field + + /// Field number for the "info" field. + public const int InfoFieldNumber = 2; + private global::LiveKit.Proto.AudioResamplerInfo info_; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public void ClearType() { - _hasBits0 &= ~1; + public global::LiveKit.Proto.AudioResamplerInfo Info { + get { return info_; } + set { + info_ = value; + } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override bool Equals(object other) { - return Equals(other as AudioSourceInfo); + return Equals(other as OwnedAudioResampler); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool Equals(AudioSourceInfo other) { + public bool Equals(OwnedAudioResampler other) { if (ReferenceEquals(other, null)) { return false; } if (ReferenceEquals(other, this)) { return true; } - if (Type != other.Type) return false; + if (!object.Equals(Handle, other.Handle)) return false; + if (!object.Equals(Info, other.Info)) return false; return Equals(_unknownFields, other._unknownFields); } @@ -8354,7 +11559,8 @@ public bool Equals(AudioSourceInfo other) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override int GetHashCode() { int hash = 1; - if (HasType) hash ^= Type.GetHashCode(); + if (handle_ != null) hash ^= Handle.GetHashCode(); + if (info_ != null) hash ^= Info.GetHashCode(); if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } @@ -8373,9 +11579,13 @@ public void WriteTo(pb::CodedOutputStream output) { #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE output.WriteRawMessage(this); #else - if (HasType) { - output.WriteRawTag(16); - output.WriteEnum((int) Type); + if (handle_ != null) { + output.WriteRawTag(10); + output.WriteMessage(Handle); + } + if (info_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Info); } if (_unknownFields != null) { _unknownFields.WriteTo(output); @@ -8387,9 +11597,13 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { - if (HasType) { - output.WriteRawTag(16); - output.WriteEnum((int) Type); + if (handle_ != null) { + output.WriteRawTag(10); + output.WriteMessage(Handle); + } + if (info_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Info); } if (_unknownFields != null) { _unknownFields.WriteTo(ref output); @@ -8401,8 +11615,11 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public int CalculateSize() { int size = 0; - if (HasType) { - size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) Type); + if (handle_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Handle); + } + if (info_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Info); } if (_unknownFields != null) { size += _unknownFields.CalculateSize(); @@ -8412,12 +11629,21 @@ public int CalculateSize() { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public void MergeFrom(AudioSourceInfo other) { + public void MergeFrom(OwnedAudioResampler other) { if (other == null) { return; } - if (other.HasType) { - Type = other.Type; + if (other.handle_ != null) { + if (handle_ == null) { + Handle = new global::LiveKit.Proto.FfiOwnedHandle(); + } + Handle.MergeFrom(other.Handle); + } + if (other.info_ != null) { + if (info_ == null) { + Info = new global::LiveKit.Proto.AudioResamplerInfo(); + } + Info.MergeFrom(other.Info); } _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); } @@ -8438,8 +11664,18 @@ public void MergeFrom(pb::CodedInputStream input) { default: _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); break; - case 16: { - Type = (global::LiveKit.Proto.AudioSourceType) input.ReadEnum(); + case 10: { + if (handle_ == null) { + Handle = new global::LiveKit.Proto.FfiOwnedHandle(); + } + input.ReadMessage(Handle); + break; + } + case 18: { + if (info_ == null) { + Info = new global::LiveKit.Proto.AudioResamplerInfo(); + } + input.ReadMessage(Info); break; } } @@ -8461,8 +11697,18 @@ public void MergeFrom(pb::CodedInputStream input) { default: _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); break; - case 16: { - Type = (global::LiveKit.Proto.AudioSourceType) input.ReadEnum(); + case 10: { + if (handle_ == null) { + Handle = new global::LiveKit.Proto.FfiOwnedHandle(); + } + input.ReadMessage(Handle); + break; + } + case 18: { + if (info_ == null) { + Info = new global::LiveKit.Proto.AudioResamplerInfo(); + } + input.ReadMessage(Info); break; } } @@ -8473,21 +11719,21 @@ public void MergeFrom(pb::CodedInputStream input) { } [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] - public sealed partial class OwnedAudioSource : pb::IMessage + public sealed partial class OwnedApm : pb::IMessage #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE , pb::IBufferMessage #endif { - private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new OwnedAudioSource()); + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new OwnedApm()); private pb::UnknownFieldSet _unknownFields; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public static pb::MessageParser Parser { get { return _parser; } } + public static pb::MessageParser Parser { get { return _parser; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::LiveKit.Proto.AudioFrameReflection.Descriptor.MessageTypes[30]; } + get { return global::LiveKit.Proto.AudioFrameReflection.Descriptor.MessageTypes[41]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -8498,7 +11744,7 @@ public sealed partial class OwnedAudioSource : pb::IMessage [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public OwnedAudioSource() { + public OwnedApm() { OnConstruction(); } @@ -8506,16 +11752,15 @@ public OwnedAudioSource() { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public OwnedAudioSource(OwnedAudioSource other) : this() { + public OwnedApm(OwnedApm other) : this() { handle_ = other.handle_ != null ? other.handle_.Clone() : null; - info_ = other.info_ != null ? other.info_.Clone() : null; _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public OwnedAudioSource Clone() { - return new OwnedAudioSource(this); + public OwnedApm Clone() { + return new OwnedApm(this); } /// Field number for the "handle" field. @@ -8530,27 +11775,15 @@ public OwnedAudioSource Clone() { } } - /// Field number for the "info" field. - public const int InfoFieldNumber = 2; - private global::LiveKit.Proto.AudioSourceInfo info_; - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public global::LiveKit.Proto.AudioSourceInfo Info { - get { return info_; } - set { - info_ = value; - } - } - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override bool Equals(object other) { - return Equals(other as OwnedAudioSource); + return Equals(other as OwnedApm); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool Equals(OwnedAudioSource other) { + public bool Equals(OwnedApm other) { if (ReferenceEquals(other, null)) { return false; } @@ -8558,7 +11791,6 @@ public bool Equals(OwnedAudioSource other) { return true; } if (!object.Equals(Handle, other.Handle)) return false; - if (!object.Equals(Info, other.Info)) return false; return Equals(_unknownFields, other._unknownFields); } @@ -8567,7 +11799,6 @@ public bool Equals(OwnedAudioSource other) { public override int GetHashCode() { int hash = 1; if (handle_ != null) hash ^= Handle.GetHashCode(); - if (info_ != null) hash ^= Info.GetHashCode(); if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } @@ -8590,10 +11821,6 @@ public void WriteTo(pb::CodedOutputStream output) { output.WriteRawTag(10); output.WriteMessage(Handle); } - if (info_ != null) { - output.WriteRawTag(18); - output.WriteMessage(Info); - } if (_unknownFields != null) { _unknownFields.WriteTo(output); } @@ -8608,10 +11835,6 @@ public void WriteTo(pb::CodedOutputStream output) { output.WriteRawTag(10); output.WriteMessage(Handle); } - if (info_ != null) { - output.WriteRawTag(18); - output.WriteMessage(Info); - } if (_unknownFields != null) { _unknownFields.WriteTo(ref output); } @@ -8625,9 +11848,6 @@ public int CalculateSize() { if (handle_ != null) { size += 1 + pb::CodedOutputStream.ComputeMessageSize(Handle); } - if (info_ != null) { - size += 1 + pb::CodedOutputStream.ComputeMessageSize(Info); - } if (_unknownFields != null) { size += _unknownFields.CalculateSize(); } @@ -8636,7 +11856,7 @@ public int CalculateSize() { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public void MergeFrom(OwnedAudioSource other) { + public void MergeFrom(OwnedApm other) { if (other == null) { return; } @@ -8646,12 +11866,6 @@ public void MergeFrom(OwnedAudioSource other) { } Handle.MergeFrom(other.Handle); } - if (other.info_ != null) { - if (info_ == null) { - Info = new global::LiveKit.Proto.AudioSourceInfo(); - } - Info.MergeFrom(other.Info); - } _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); } @@ -8678,13 +11892,6 @@ public void MergeFrom(pb::CodedInputStream input) { input.ReadMessage(Handle); break; } - case 18: { - if (info_ == null) { - Info = new global::LiveKit.Proto.AudioSourceInfo(); - } - input.ReadMessage(Info); - break; - } } } #endif @@ -8711,13 +11918,6 @@ public void MergeFrom(pb::CodedInputStream input) { input.ReadMessage(Handle); break; } - case 18: { - if (info_ == null) { - Info = new global::LiveKit.Proto.AudioSourceInfo(); - } - input.ReadMessage(Info); - break; - } } } } @@ -8726,21 +11926,21 @@ public void MergeFrom(pb::CodedInputStream input) { } [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] - public sealed partial class AudioResamplerInfo : pb::IMessage + public sealed partial class SoxResamplerInfo : pb::IMessage #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE , pb::IBufferMessage #endif { - private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new AudioResamplerInfo()); + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new SoxResamplerInfo()); private pb::UnknownFieldSet _unknownFields; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public static pb::MessageParser Parser { get { return _parser; } } + public static pb::MessageParser Parser { get { return _parser; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::LiveKit.Proto.AudioFrameReflection.Descriptor.MessageTypes[31]; } + get { return global::LiveKit.Proto.AudioFrameReflection.Descriptor.MessageTypes[42]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -8751,7 +11951,7 @@ public sealed partial class AudioResamplerInfo : pb::IMessage + public sealed partial class OwnedSoxResampler : pb::IMessage #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE , pb::IBufferMessage #endif { - private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new OwnedAudioResampler()); + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new OwnedSoxResampler()); private pb::UnknownFieldSet _unknownFields; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public static pb::MessageParser Parser { get { return _parser; } } + public static pb::MessageParser Parser { get { return _parser; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::LiveKit.Proto.AudioFrameReflection.Descriptor.MessageTypes[32]; } + get { return global::LiveKit.Proto.AudioFrameReflection.Descriptor.MessageTypes[43]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -8912,7 +12112,7 @@ public sealed partial class OwnedAudioResampler : pb::IMessageField number for the "handle" field. @@ -8946,10 +12146,10 @@ public OwnedAudioResampler Clone() { /// Field number for the "info" field. public const int InfoFieldNumber = 2; - private global::LiveKit.Proto.AudioResamplerInfo info_; + private global::LiveKit.Proto.SoxResamplerInfo info_; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public global::LiveKit.Proto.AudioResamplerInfo Info { + public global::LiveKit.Proto.SoxResamplerInfo Info { get { return info_; } set { info_ = value; @@ -8959,12 +12159,12 @@ public OwnedAudioResampler Clone() { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override bool Equals(object other) { - return Equals(other as OwnedAudioResampler); + return Equals(other as OwnedSoxResampler); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool Equals(OwnedAudioResampler other) { + public bool Equals(OwnedSoxResampler other) { if (ReferenceEquals(other, null)) { return false; } @@ -9050,7 +12250,7 @@ public int CalculateSize() { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public void MergeFrom(OwnedAudioResampler other) { + public void MergeFrom(OwnedSoxResampler other) { if (other == null) { return; } @@ -9062,7 +12262,7 @@ public void MergeFrom(OwnedAudioResampler other) { } if (other.info_ != null) { if (info_ == null) { - Info = new global::LiveKit.Proto.AudioResamplerInfo(); + Info = new global::LiveKit.Proto.SoxResamplerInfo(); } Info.MergeFrom(other.Info); } @@ -9094,7 +12294,7 @@ public void MergeFrom(pb::CodedInputStream input) { } case 18: { if (info_ == null) { - Info = new global::LiveKit.Proto.AudioResamplerInfo(); + Info = new global::LiveKit.Proto.SoxResamplerInfo(); } input.ReadMessage(Info); break; @@ -9127,7 +12327,7 @@ public void MergeFrom(pb::CodedInputStream input) { } case 18: { if (info_ == null) { - Info = new global::LiveKit.Proto.AudioResamplerInfo(); + Info = new global::LiveKit.Proto.SoxResamplerInfo(); } input.ReadMessage(Info); break; @@ -9139,22 +12339,25 @@ public void MergeFrom(pb::CodedInputStream input) { } + /// + /// Audio Filter Plugin + /// [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] - public sealed partial class SoxResamplerInfo : pb::IMessage + public sealed partial class LoadAudioFilterPluginRequest : pb::IMessage #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE , pb::IBufferMessage #endif { - private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new SoxResamplerInfo()); + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new LoadAudioFilterPluginRequest()); private pb::UnknownFieldSet _unknownFields; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public static pb::MessageParser Parser { get { return _parser; } } + public static pb::MessageParser Parser { get { return _parser; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::LiveKit.Proto.AudioFrameReflection.Descriptor.MessageTypes[33]; } + get { return global::LiveKit.Proto.AudioFrameReflection.Descriptor.MessageTypes[44]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -9165,7 +12368,7 @@ public sealed partial class SoxResamplerInfo : pb::IMessage [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public SoxResamplerInfo() { + public LoadAudioFilterPluginRequest() { OnConstruction(); } @@ -9173,31 +12376,109 @@ public SoxResamplerInfo() { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public SoxResamplerInfo(SoxResamplerInfo other) : this() { + public LoadAudioFilterPluginRequest(LoadAudioFilterPluginRequest other) : this() { + pluginPath_ = other.pluginPath_; + dependencies_ = other.dependencies_.Clone(); + moduleId_ = other.moduleId_; _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public SoxResamplerInfo Clone() { - return new SoxResamplerInfo(this); + public LoadAudioFilterPluginRequest Clone() { + return new LoadAudioFilterPluginRequest(this); + } + + /// Field number for the "plugin_path" field. + public const int PluginPathFieldNumber = 1; + private readonly static string PluginPathDefaultValue = ""; + + private string pluginPath_; + /// + /// path for ffi audio filter plugin + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string PluginPath { + get { return pluginPath_ ?? PluginPathDefaultValue; } + set { + pluginPath_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + /// Gets whether the "plugin_path" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasPluginPath { + get { return pluginPath_ != null; } + } + /// Clears the value of the "plugin_path" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearPluginPath() { + pluginPath_ = null; + } + + /// Field number for the "dependencies" field. + public const int DependenciesFieldNumber = 2; + private static readonly pb::FieldCodec _repeated_dependencies_codec + = pb::FieldCodec.ForString(18); + private readonly pbc::RepeatedField dependencies_ = new pbc::RepeatedField(); + /// + /// Optional: paths for dependency dylibs + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField Dependencies { + get { return dependencies_; } + } + + /// Field number for the "module_id" field. + public const int ModuleIdFieldNumber = 3; + private readonly static string ModuleIdDefaultValue = ""; + + private string moduleId_; + /// + /// Unique identifier of the plugin + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string ModuleId { + get { return moduleId_ ?? ModuleIdDefaultValue; } + set { + moduleId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + /// Gets whether the "module_id" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasModuleId { + get { return moduleId_ != null; } + } + /// Clears the value of the "module_id" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearModuleId() { + moduleId_ = null; } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override bool Equals(object other) { - return Equals(other as SoxResamplerInfo); + return Equals(other as LoadAudioFilterPluginRequest); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool Equals(SoxResamplerInfo other) { + public bool Equals(LoadAudioFilterPluginRequest other) { if (ReferenceEquals(other, null)) { return false; } if (ReferenceEquals(other, this)) { return true; } + if (PluginPath != other.PluginPath) return false; + if(!dependencies_.Equals(other.dependencies_)) return false; + if (ModuleId != other.ModuleId) return false; return Equals(_unknownFields, other._unknownFields); } @@ -9205,6 +12486,9 @@ public bool Equals(SoxResamplerInfo other) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override int GetHashCode() { int hash = 1; + if (HasPluginPath) hash ^= PluginPath.GetHashCode(); + hash ^= dependencies_.GetHashCode(); + if (HasModuleId) hash ^= ModuleId.GetHashCode(); if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } @@ -9223,6 +12507,15 @@ public void WriteTo(pb::CodedOutputStream output) { #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE output.WriteRawMessage(this); #else + if (HasPluginPath) { + output.WriteRawTag(10); + output.WriteString(PluginPath); + } + dependencies_.WriteTo(output, _repeated_dependencies_codec); + if (HasModuleId) { + output.WriteRawTag(26); + output.WriteString(ModuleId); + } if (_unknownFields != null) { _unknownFields.WriteTo(output); } @@ -9233,6 +12526,15 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (HasPluginPath) { + output.WriteRawTag(10); + output.WriteString(PluginPath); + } + dependencies_.WriteTo(ref output, _repeated_dependencies_codec); + if (HasModuleId) { + output.WriteRawTag(26); + output.WriteString(ModuleId); + } if (_unknownFields != null) { _unknownFields.WriteTo(ref output); } @@ -9243,6 +12545,13 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public int CalculateSize() { int size = 0; + if (HasPluginPath) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(PluginPath); + } + size += dependencies_.CalculateSize(_repeated_dependencies_codec); + if (HasModuleId) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(ModuleId); + } if (_unknownFields != null) { size += _unknownFields.CalculateSize(); } @@ -9251,10 +12560,17 @@ public int CalculateSize() { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public void MergeFrom(SoxResamplerInfo other) { + public void MergeFrom(LoadAudioFilterPluginRequest other) { if (other == null) { return; } + if (other.HasPluginPath) { + PluginPath = other.PluginPath; + } + dependencies_.Add(other.dependencies_); + if (other.HasModuleId) { + ModuleId = other.ModuleId; + } _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); } @@ -9274,6 +12590,18 @@ public void MergeFrom(pb::CodedInputStream input) { default: _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); break; + case 10: { + PluginPath = input.ReadString(); + break; + } + case 18: { + dependencies_.AddEntriesFrom(input, _repeated_dependencies_codec); + break; + } + case 26: { + ModuleId = input.ReadString(); + break; + } } } #endif @@ -9293,6 +12621,18 @@ public void MergeFrom(pb::CodedInputStream input) { default: _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); break; + case 10: { + PluginPath = input.ReadString(); + break; + } + case 18: { + dependencies_.AddEntriesFrom(ref input, _repeated_dependencies_codec); + break; + } + case 26: { + ModuleId = input.ReadString(); + break; + } } } } @@ -9301,21 +12641,21 @@ public void MergeFrom(pb::CodedInputStream input) { } [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] - public sealed partial class OwnedSoxResampler : pb::IMessage + public sealed partial class LoadAudioFilterPluginResponse : pb::IMessage #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE , pb::IBufferMessage #endif { - private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new OwnedSoxResampler()); + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new LoadAudioFilterPluginResponse()); private pb::UnknownFieldSet _unknownFields; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public static pb::MessageParser Parser { get { return _parser; } } + public static pb::MessageParser Parser { get { return _parser; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::LiveKit.Proto.AudioFrameReflection.Descriptor.MessageTypes[34]; } + get { return global::LiveKit.Proto.AudioFrameReflection.Descriptor.MessageTypes[45]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -9326,7 +12666,7 @@ public sealed partial class OwnedSoxResampler : pb::IMessage [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public OwnedSoxResampler() { + public LoadAudioFilterPluginResponse() { OnConstruction(); } @@ -9334,59 +12674,59 @@ public OwnedSoxResampler() { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public OwnedSoxResampler(OwnedSoxResampler other) : this() { - handle_ = other.handle_ != null ? other.handle_.Clone() : null; - info_ = other.info_ != null ? other.info_.Clone() : null; + public LoadAudioFilterPluginResponse(LoadAudioFilterPluginResponse other) : this() { + error_ = other.error_; _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public OwnedSoxResampler Clone() { - return new OwnedSoxResampler(this); + public LoadAudioFilterPluginResponse Clone() { + return new LoadAudioFilterPluginResponse(this); } - /// Field number for the "handle" field. - public const int HandleFieldNumber = 1; - private global::LiveKit.Proto.FfiOwnedHandle handle_; + /// Field number for the "error" field. + public const int ErrorFieldNumber = 1; + private readonly static string ErrorDefaultValue = ""; + + private string error_; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public global::LiveKit.Proto.FfiOwnedHandle Handle { - get { return handle_; } + public string Error { + get { return error_ ?? ErrorDefaultValue; } set { - handle_ = value; + error_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); } } - - /// Field number for the "info" field. - public const int InfoFieldNumber = 2; - private global::LiveKit.Proto.SoxResamplerInfo info_; + /// Gets whether the "error" field is set [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public global::LiveKit.Proto.SoxResamplerInfo Info { - get { return info_; } - set { - info_ = value; - } + public bool HasError { + get { return error_ != null; } + } + /// Clears the value of the "error" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearError() { + error_ = null; } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override bool Equals(object other) { - return Equals(other as OwnedSoxResampler); + return Equals(other as LoadAudioFilterPluginResponse); } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool Equals(OwnedSoxResampler other) { + public bool Equals(LoadAudioFilterPluginResponse other) { if (ReferenceEquals(other, null)) { return false; } if (ReferenceEquals(other, this)) { return true; } - if (!object.Equals(Handle, other.Handle)) return false; - if (!object.Equals(Info, other.Info)) return false; + if (Error != other.Error) return false; return Equals(_unknownFields, other._unknownFields); } @@ -9394,8 +12734,7 @@ public bool Equals(OwnedSoxResampler other) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override int GetHashCode() { int hash = 1; - if (handle_ != null) hash ^= Handle.GetHashCode(); - if (info_ != null) hash ^= Info.GetHashCode(); + if (HasError) hash ^= Error.GetHashCode(); if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } @@ -9414,13 +12753,9 @@ public void WriteTo(pb::CodedOutputStream output) { #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE output.WriteRawMessage(this); #else - if (handle_ != null) { + if (HasError) { output.WriteRawTag(10); - output.WriteMessage(Handle); - } - if (info_ != null) { - output.WriteRawTag(18); - output.WriteMessage(Info); + output.WriteString(Error); } if (_unknownFields != null) { _unknownFields.WriteTo(output); @@ -9432,13 +12767,9 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { - if (handle_ != null) { + if (HasError) { output.WriteRawTag(10); - output.WriteMessage(Handle); - } - if (info_ != null) { - output.WriteRawTag(18); - output.WriteMessage(Info); + output.WriteString(Error); } if (_unknownFields != null) { _unknownFields.WriteTo(ref output); @@ -9450,11 +12781,8 @@ public void WriteTo(pb::CodedOutputStream output) { [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public int CalculateSize() { int size = 0; - if (handle_ != null) { - size += 1 + pb::CodedOutputStream.ComputeMessageSize(Handle); - } - if (info_ != null) { - size += 1 + pb::CodedOutputStream.ComputeMessageSize(Info); + if (HasError) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Error); } if (_unknownFields != null) { size += _unknownFields.CalculateSize(); @@ -9464,21 +12792,12 @@ public int CalculateSize() { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public void MergeFrom(OwnedSoxResampler other) { + public void MergeFrom(LoadAudioFilterPluginResponse other) { if (other == null) { return; } - if (other.handle_ != null) { - if (handle_ == null) { - Handle = new global::LiveKit.Proto.FfiOwnedHandle(); - } - Handle.MergeFrom(other.Handle); - } - if (other.info_ != null) { - if (info_ == null) { - Info = new global::LiveKit.Proto.SoxResamplerInfo(); - } - Info.MergeFrom(other.Info); + if (other.HasError) { + Error = other.Error; } _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); } @@ -9500,17 +12819,7 @@ public void MergeFrom(pb::CodedInputStream input) { _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); break; case 10: { - if (handle_ == null) { - Handle = new global::LiveKit.Proto.FfiOwnedHandle(); - } - input.ReadMessage(Handle); - break; - } - case 18: { - if (info_ == null) { - Info = new global::LiveKit.Proto.SoxResamplerInfo(); - } - input.ReadMessage(Info); + Error = input.ReadString(); break; } } @@ -9533,17 +12842,7 @@ public void MergeFrom(pb::CodedInputStream input) { _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); break; case 10: { - if (handle_ == null) { - Handle = new global::LiveKit.Proto.FfiOwnedHandle(); - } - input.ReadMessage(Handle); - break; - } - case 18: { - if (info_ == null) { - Info = new global::LiveKit.Proto.SoxResamplerInfo(); - } - input.ReadMessage(Info); + Error = input.ReadString(); break; } } diff --git a/Runtime/Scripts/Proto/DataStream.cs b/Runtime/Scripts/Proto/DataStream.cs new file mode 100644 index 00000000..75925ffa --- /dev/null +++ b/Runtime/Scripts/Proto/DataStream.cs @@ -0,0 +1,14857 @@ +// +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: data_stream.proto +// +#pragma warning disable 1591, 0612, 3021, 8981 +#region Designer generated code + +using pb = global::Google.Protobuf; +using pbc = global::Google.Protobuf.Collections; +using pbr = global::Google.Protobuf.Reflection; +using scg = global::System.Collections.Generic; +namespace LiveKit.Proto { + + /// Holder for reflection information generated from data_stream.proto + public static partial class DataStreamReflection { + + #region Descriptor + /// File descriptor for data_stream.proto + public static pbr::FileDescriptor Descriptor { + get { return descriptor; } + } + private static pbr::FileDescriptor descriptor; + + static DataStreamReflection() { + byte[] descriptorData = global::System.Convert.FromBase64String( + string.Concat( + "ChFkYXRhX3N0cmVhbS5wcm90bxINbGl2ZWtpdC5wcm90bxoMaGFuZGxlLnBy", + "b3RvInMKFU93bmVkVGV4dFN0cmVhbVJlYWRlchItCgZoYW5kbGUYASACKAsy", + "HS5saXZla2l0LnByb3RvLkZmaU93bmVkSGFuZGxlEisKBGluZm8YAiACKAsy", + "HS5saXZla2l0LnByb3RvLlRleHRTdHJlYW1JbmZvIj8KJlRleHRTdHJlYW1S", + "ZWFkZXJSZWFkSW5jcmVtZW50YWxSZXF1ZXN0EhUKDXJlYWRlcl9oYW5kbGUY", + "ASACKAQiKQonVGV4dFN0cmVhbVJlYWRlclJlYWRJbmNyZW1lbnRhbFJlc3Bv", + "bnNlIjcKHlRleHRTdHJlYW1SZWFkZXJSZWFkQWxsUmVxdWVzdBIVCg1yZWFk", + "ZXJfaGFuZGxlGAEgAigEIjMKH1RleHRTdHJlYW1SZWFkZXJSZWFkQWxsUmVz", + "cG9uc2USEAoIYXN5bmNfaWQYASACKAQifQofVGV4dFN0cmVhbVJlYWRlclJl", + "YWRBbGxDYWxsYmFjaxIQCghhc3luY19pZBgBIAIoBBIRCgdjb250ZW50GAIg", + "ASgJSAASKwoFZXJyb3IYAyABKAsyGi5saXZla2l0LnByb3RvLlN0cmVhbUVy", + "cm9ySABCCAoGcmVzdWx0IrMBChVUZXh0U3RyZWFtUmVhZGVyRXZlbnQSFQoN", + "cmVhZGVyX2hhbmRsZRgBIAIoBBJGCg5jaHVua19yZWNlaXZlZBgCIAEoCzIs", + "LmxpdmVraXQucHJvdG8uVGV4dFN0cmVhbVJlYWRlckNodW5rUmVjZWl2ZWRI", + "ABIxCgNlb3MYAyABKAsyIi5saXZla2l0LnByb3RvLlRleHRTdHJlYW1SZWFk", + "ZXJFT1NIAEIICgZkZXRhaWwiMAodVGV4dFN0cmVhbVJlYWRlckNodW5rUmVj", + "ZWl2ZWQSDwoHY29udGVudBgBIAIoCSJAChNUZXh0U3RyZWFtUmVhZGVyRU9T", + "EikKBWVycm9yGAEgASgLMhoubGl2ZWtpdC5wcm90by5TdHJlYW1FcnJvciJz", + "ChVPd25lZEJ5dGVTdHJlYW1SZWFkZXISLQoGaGFuZGxlGAEgAigLMh0ubGl2", + "ZWtpdC5wcm90by5GZmlPd25lZEhhbmRsZRIrCgRpbmZvGAIgAigLMh0ubGl2", + "ZWtpdC5wcm90by5CeXRlU3RyZWFtSW5mbyI/CiZCeXRlU3RyZWFtUmVhZGVy", + "UmVhZEluY3JlbWVudGFsUmVxdWVzdBIVCg1yZWFkZXJfaGFuZGxlGAEgAigE", + "IikKJ0J5dGVTdHJlYW1SZWFkZXJSZWFkSW5jcmVtZW50YWxSZXNwb25zZSI3", + "Ch5CeXRlU3RyZWFtUmVhZGVyUmVhZEFsbFJlcXVlc3QSFQoNcmVhZGVyX2hh", + "bmRsZRgBIAIoBCIzCh9CeXRlU3RyZWFtUmVhZGVyUmVhZEFsbFJlc3BvbnNl", + "EhAKCGFzeW5jX2lkGAEgAigEIn0KH0J5dGVTdHJlYW1SZWFkZXJSZWFkQWxs", + "Q2FsbGJhY2sSEAoIYXN5bmNfaWQYASACKAQSEQoHY29udGVudBgCIAEoDEgA", + "EisKBWVycm9yGAMgASgLMhoubGl2ZWtpdC5wcm90by5TdHJlYW1FcnJvckgA", + "QggKBnJlc3VsdCJlCiJCeXRlU3RyZWFtUmVhZGVyV3JpdGVUb0ZpbGVSZXF1", + "ZXN0EhUKDXJlYWRlcl9oYW5kbGUYASACKAQSEQoJZGlyZWN0b3J5GAMgASgJ", + "EhUKDW5hbWVfb3ZlcnJpZGUYBCABKAkiNwojQnl0ZVN0cmVhbVJlYWRlcldy", + "aXRlVG9GaWxlUmVzcG9uc2USEAoIYXN5bmNfaWQYASACKAQigwEKI0J5dGVT", + "dHJlYW1SZWFkZXJXcml0ZVRvRmlsZUNhbGxiYWNrEhAKCGFzeW5jX2lkGAEg", + "AigEEhMKCWZpbGVfcGF0aBgCIAEoCUgAEisKBWVycm9yGAMgASgLMhoubGl2", + "ZWtpdC5wcm90by5TdHJlYW1FcnJvckgAQggKBnJlc3VsdCKzAQoVQnl0ZVN0", + "cmVhbVJlYWRlckV2ZW50EhUKDXJlYWRlcl9oYW5kbGUYASACKAQSRgoOY2h1", + "bmtfcmVjZWl2ZWQYAiABKAsyLC5saXZla2l0LnByb3RvLkJ5dGVTdHJlYW1S", + "ZWFkZXJDaHVua1JlY2VpdmVkSAASMQoDZW9zGAMgASgLMiIubGl2ZWtpdC5w", + "cm90by5CeXRlU3RyZWFtUmVhZGVyRU9TSABCCAoGZGV0YWlsIjAKHUJ5dGVT", + "dHJlYW1SZWFkZXJDaHVua1JlY2VpdmVkEg8KB2NvbnRlbnQYASACKAwiQAoT", + "Qnl0ZVN0cmVhbVJlYWRlckVPUxIpCgVlcnJvchgBIAEoCzIaLmxpdmVraXQu", + "cHJvdG8uU3RyZWFtRXJyb3IifwoVU3RyZWFtU2VuZEZpbGVSZXF1ZXN0EiAK", + "GGxvY2FsX3BhcnRpY2lwYW50X2hhbmRsZRgBIAIoBBIxCgdvcHRpb25zGAIg", + "AigLMiAubGl2ZWtpdC5wcm90by5TdHJlYW1CeXRlT3B0aW9ucxIRCglmaWxl", + "X3BhdGgYAyACKAkiKgoWU3RyZWFtU2VuZEZpbGVSZXNwb25zZRIQCghhc3lu", + "Y19pZBgBIAIoBCKQAQoWU3RyZWFtU2VuZEZpbGVDYWxsYmFjaxIQCghhc3lu", + "Y19pZBgBIAIoBBItCgRpbmZvGAIgASgLMh0ubGl2ZWtpdC5wcm90by5CeXRl", + "U3RyZWFtSW5mb0gAEisKBWVycm9yGAMgASgLMhoubGl2ZWtpdC5wcm90by5T", + "dHJlYW1FcnJvckgAQggKBnJlc3VsdCJ6ChVTdHJlYW1TZW5kVGV4dFJlcXVl", + "c3QSIAoYbG9jYWxfcGFydGljaXBhbnRfaGFuZGxlGAEgAigEEjEKB29wdGlv", + "bnMYAiACKAsyIC5saXZla2l0LnByb3RvLlN0cmVhbVRleHRPcHRpb25zEgwK", + "BHRleHQYAyACKAkiKgoWU3RyZWFtU2VuZFRleHRSZXNwb25zZRIQCghhc3lu", + "Y19pZBgBIAIoBCKQAQoWU3RyZWFtU2VuZFRleHRDYWxsYmFjaxIQCghhc3lu", + "Y19pZBgBIAIoBBItCgRpbmZvGAIgASgLMh0ubGl2ZWtpdC5wcm90by5UZXh0", + "U3RyZWFtSW5mb0gAEisKBWVycm9yGAMgASgLMhoubGl2ZWtpdC5wcm90by5T", + "dHJlYW1FcnJvckgAQggKBnJlc3VsdCJzChVPd25lZEJ5dGVTdHJlYW1Xcml0", + "ZXISLQoGaGFuZGxlGAEgAigLMh0ubGl2ZWtpdC5wcm90by5GZmlPd25lZEhh", + "bmRsZRIrCgRpbmZvGAIgAigLMh0ubGl2ZWtpdC5wcm90by5CeXRlU3RyZWFt", + "SW5mbyJsChVCeXRlU3RyZWFtT3BlblJlcXVlc3QSIAoYbG9jYWxfcGFydGlj", + "aXBhbnRfaGFuZGxlGAEgAigEEjEKB29wdGlvbnMYAiACKAsyIC5saXZla2l0", + "LnByb3RvLlN0cmVhbUJ5dGVPcHRpb25zIioKFkJ5dGVTdHJlYW1PcGVuUmVz", + "cG9uc2USEAoIYXN5bmNfaWQYASACKAQimQEKFkJ5dGVTdHJlYW1PcGVuQ2Fs", + "bGJhY2sSEAoIYXN5bmNfaWQYASACKAQSNgoGd3JpdGVyGAIgASgLMiQubGl2", + "ZWtpdC5wcm90by5Pd25lZEJ5dGVTdHJlYW1Xcml0ZXJIABIrCgVlcnJvchgD", + "IAEoCzIaLmxpdmVraXQucHJvdG8uU3RyZWFtRXJyb3JIAEIICgZyZXN1bHQi", + "RAocQnl0ZVN0cmVhbVdyaXRlcldyaXRlUmVxdWVzdBIVCg13cml0ZXJfaGFu", + "ZGxlGAEgAigEEg0KBWJ5dGVzGAIgAigMIjEKHUJ5dGVTdHJlYW1Xcml0ZXJX", + "cml0ZVJlc3BvbnNlEhAKCGFzeW5jX2lkGAEgAigEIlwKHUJ5dGVTdHJlYW1X", + "cml0ZXJXcml0ZUNhbGxiYWNrEhAKCGFzeW5jX2lkGAEgAigEEikKBWVycm9y", + "GAIgASgLMhoubGl2ZWtpdC5wcm90by5TdHJlYW1FcnJvciJFChxCeXRlU3Ry", + "ZWFtV3JpdGVyQ2xvc2VSZXF1ZXN0EhUKDXdyaXRlcl9oYW5kbGUYASACKAQS", + "DgoGcmVhc29uGAIgASgJIjEKHUJ5dGVTdHJlYW1Xcml0ZXJDbG9zZVJlc3Bv", + "bnNlEhAKCGFzeW5jX2lkGAEgAigEIlwKHUJ5dGVTdHJlYW1Xcml0ZXJDbG9z", + "ZUNhbGxiYWNrEhAKCGFzeW5jX2lkGAEgAigEEikKBWVycm9yGAIgASgLMhou", + "bGl2ZWtpdC5wcm90by5TdHJlYW1FcnJvciJzChVPd25lZFRleHRTdHJlYW1X", + "cml0ZXISLQoGaGFuZGxlGAEgAigLMh0ubGl2ZWtpdC5wcm90by5GZmlPd25l", + "ZEhhbmRsZRIrCgRpbmZvGAIgAigLMh0ubGl2ZWtpdC5wcm90by5UZXh0U3Ry", + "ZWFtSW5mbyJsChVUZXh0U3RyZWFtT3BlblJlcXVlc3QSIAoYbG9jYWxfcGFy", + "dGljaXBhbnRfaGFuZGxlGAEgAigEEjEKB29wdGlvbnMYAiACKAsyIC5saXZl", + "a2l0LnByb3RvLlN0cmVhbVRleHRPcHRpb25zIioKFlRleHRTdHJlYW1PcGVu", + "UmVzcG9uc2USEAoIYXN5bmNfaWQYASACKAQimQEKFlRleHRTdHJlYW1PcGVu", + "Q2FsbGJhY2sSEAoIYXN5bmNfaWQYASACKAQSNgoGd3JpdGVyGAIgASgLMiQu", + "bGl2ZWtpdC5wcm90by5Pd25lZFRleHRTdHJlYW1Xcml0ZXJIABIrCgVlcnJv", + "chgDIAEoCzIaLmxpdmVraXQucHJvdG8uU3RyZWFtRXJyb3JIAEIICgZyZXN1", + "bHQiQwocVGV4dFN0cmVhbVdyaXRlcldyaXRlUmVxdWVzdBIVCg13cml0ZXJf", + "aGFuZGxlGAEgAigEEgwKBHRleHQYAiACKAkiMQodVGV4dFN0cmVhbVdyaXRl", + "cldyaXRlUmVzcG9uc2USEAoIYXN5bmNfaWQYASACKAQiXAodVGV4dFN0cmVh", + "bVdyaXRlcldyaXRlQ2FsbGJhY2sSEAoIYXN5bmNfaWQYASACKAQSKQoFZXJy", + "b3IYAiABKAsyGi5saXZla2l0LnByb3RvLlN0cmVhbUVycm9yIkUKHFRleHRT", + "dHJlYW1Xcml0ZXJDbG9zZVJlcXVlc3QSFQoNd3JpdGVyX2hhbmRsZRgBIAIo", + "BBIOCgZyZWFzb24YAiABKAkiMQodVGV4dFN0cmVhbVdyaXRlckNsb3NlUmVz", + "cG9uc2USEAoIYXN5bmNfaWQYASACKAQiXAodVGV4dFN0cmVhbVdyaXRlckNs", + "b3NlQ2FsbGJhY2sSEAoIYXN5bmNfaWQYASACKAQSKQoFZXJyb3IYAiABKAsy", + "Gi5saXZla2l0LnByb3RvLlN0cmVhbUVycm9yIskDCg5UZXh0U3RyZWFtSW5m", + "bxIRCglzdHJlYW1faWQYASACKAkSEQoJdGltZXN0YW1wGAIgAigDEhEKCW1p", + "bWVfdHlwZRgDIAIoCRINCgV0b3BpYxgEIAIoCRIUCgx0b3RhbF9sZW5ndGgY", + "BSABKAQSQQoKYXR0cmlidXRlcxgGIAMoCzItLmxpdmVraXQucHJvdG8uVGV4", + "dFN0cmVhbUluZm8uQXR0cmlidXRlc0VudHJ5EkMKDm9wZXJhdGlvbl90eXBl", + "GAcgAigOMisubGl2ZWtpdC5wcm90by5UZXh0U3RyZWFtSW5mby5PcGVyYXRp", + "b25UeXBlEg8KB3ZlcnNpb24YCCABKAUSGgoScmVwbHlfdG9fc3RyZWFtX2lk", + "GAkgASgJEhsKE2F0dGFjaGVkX3N0cmVhbV9pZHMYCiADKAkSEQoJZ2VuZXJh", + "dGVkGAsgASgIGjEKD0F0dHJpYnV0ZXNFbnRyeRILCgNrZXkYASABKAkSDQoF", + "dmFsdWUYAiABKAk6AjgBIkEKDU9wZXJhdGlvblR5cGUSCgoGQ1JFQVRFEAAS", + "CgoGVVBEQVRFEAESCgoGREVMRVRFEAISDAoIUkVBQ1RJT04QAyLyAQoOQnl0", + "ZVN0cmVhbUluZm8SEQoJc3RyZWFtX2lkGAEgAigJEhEKCXRpbWVzdGFtcBgC", + "IAIoAxIRCgltaW1lX3R5cGUYAyACKAkSDQoFdG9waWMYBCACKAkSFAoMdG90", + "YWxfbGVuZ3RoGAUgASgEEkEKCmF0dHJpYnV0ZXMYBiADKAsyLS5saXZla2l0", + "LnByb3RvLkJ5dGVTdHJlYW1JbmZvLkF0dHJpYnV0ZXNFbnRyeRIMCgRuYW1l", + "GAcgAigJGjEKD0F0dHJpYnV0ZXNFbnRyeRILCgNrZXkYASABKAkSDQoFdmFs", + "dWUYAiABKAk6AjgBIukCChFTdHJlYW1UZXh0T3B0aW9ucxINCgV0b3BpYxgB", + "IAIoCRJECgphdHRyaWJ1dGVzGAIgAygLMjAubGl2ZWtpdC5wcm90by5TdHJl", + "YW1UZXh0T3B0aW9ucy5BdHRyaWJ1dGVzRW50cnkSHgoWZGVzdGluYXRpb25f", + "aWRlbnRpdGllcxgDIAMoCRIKCgJpZBgEIAEoCRJDCg5vcGVyYXRpb25fdHlw", + "ZRgFIAEoDjIrLmxpdmVraXQucHJvdG8uVGV4dFN0cmVhbUluZm8uT3BlcmF0", + "aW9uVHlwZRIPCgd2ZXJzaW9uGAYgASgFEhoKEnJlcGx5X3RvX3N0cmVhbV9p", + "ZBgHIAEoCRIbChNhdHRhY2hlZF9zdHJlYW1faWRzGAggAygJEhEKCWdlbmVy", + "YXRlZBgJIAEoCBoxCg9BdHRyaWJ1dGVzRW50cnkSCwoDa2V5GAEgASgJEg0K", + "BXZhbHVlGAIgASgJOgI4ASL+AQoRU3RyZWFtQnl0ZU9wdGlvbnMSDQoFdG9w", + "aWMYASACKAkSRAoKYXR0cmlidXRlcxgCIAMoCzIwLmxpdmVraXQucHJvdG8u", + "U3RyZWFtQnl0ZU9wdGlvbnMuQXR0cmlidXRlc0VudHJ5Eh4KFmRlc3RpbmF0", + "aW9uX2lkZW50aXRpZXMYAyADKAkSCgoCaWQYBCABKAkSDAoEbmFtZRgFIAEo", + "CRIRCgltaW1lX3R5cGUYBiABKAkSFAoMdG90YWxfbGVuZ3RoGAcgASgEGjEK", + "D0F0dHJpYnV0ZXNFbnRyeRILCgNrZXkYASABKAkSDQoFdmFsdWUYAiABKAk6", + "AjgBIiIKC1N0cmVhbUVycm9yEhMKC2Rlc2NyaXB0aW9uGAEgAigJQhCqAg1M", + "aXZlS2l0LlByb3Rv")); + descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData, + new pbr::FileDescriptor[] { global::LiveKit.Proto.HandleReflection.Descriptor, }, + new pbr::GeneratedClrTypeInfo(null, null, new pbr::GeneratedClrTypeInfo[] { + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.OwnedTextStreamReader), global::LiveKit.Proto.OwnedTextStreamReader.Parser, new[]{ "Handle", "Info" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.TextStreamReaderReadIncrementalRequest), global::LiveKit.Proto.TextStreamReaderReadIncrementalRequest.Parser, new[]{ "ReaderHandle" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.TextStreamReaderReadIncrementalResponse), global::LiveKit.Proto.TextStreamReaderReadIncrementalResponse.Parser, null, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.TextStreamReaderReadAllRequest), global::LiveKit.Proto.TextStreamReaderReadAllRequest.Parser, new[]{ "ReaderHandle" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.TextStreamReaderReadAllResponse), global::LiveKit.Proto.TextStreamReaderReadAllResponse.Parser, new[]{ "AsyncId" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.TextStreamReaderReadAllCallback), global::LiveKit.Proto.TextStreamReaderReadAllCallback.Parser, new[]{ "AsyncId", "Content", "Error" }, new[]{ "Result" }, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.TextStreamReaderEvent), global::LiveKit.Proto.TextStreamReaderEvent.Parser, new[]{ "ReaderHandle", "ChunkReceived", "Eos" }, new[]{ "Detail" }, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.TextStreamReaderChunkReceived), global::LiveKit.Proto.TextStreamReaderChunkReceived.Parser, new[]{ "Content" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.TextStreamReaderEOS), global::LiveKit.Proto.TextStreamReaderEOS.Parser, new[]{ "Error" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.OwnedByteStreamReader), global::LiveKit.Proto.OwnedByteStreamReader.Parser, new[]{ "Handle", "Info" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.ByteStreamReaderReadIncrementalRequest), global::LiveKit.Proto.ByteStreamReaderReadIncrementalRequest.Parser, new[]{ "ReaderHandle" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.ByteStreamReaderReadIncrementalResponse), global::LiveKit.Proto.ByteStreamReaderReadIncrementalResponse.Parser, null, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.ByteStreamReaderReadAllRequest), global::LiveKit.Proto.ByteStreamReaderReadAllRequest.Parser, new[]{ "ReaderHandle" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.ByteStreamReaderReadAllResponse), global::LiveKit.Proto.ByteStreamReaderReadAllResponse.Parser, new[]{ "AsyncId" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.ByteStreamReaderReadAllCallback), global::LiveKit.Proto.ByteStreamReaderReadAllCallback.Parser, new[]{ "AsyncId", "Content", "Error" }, new[]{ "Result" }, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.ByteStreamReaderWriteToFileRequest), global::LiveKit.Proto.ByteStreamReaderWriteToFileRequest.Parser, new[]{ "ReaderHandle", "Directory", "NameOverride" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.ByteStreamReaderWriteToFileResponse), global::LiveKit.Proto.ByteStreamReaderWriteToFileResponse.Parser, new[]{ "AsyncId" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.ByteStreamReaderWriteToFileCallback), global::LiveKit.Proto.ByteStreamReaderWriteToFileCallback.Parser, new[]{ "AsyncId", "FilePath", "Error" }, new[]{ "Result" }, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.ByteStreamReaderEvent), global::LiveKit.Proto.ByteStreamReaderEvent.Parser, new[]{ "ReaderHandle", "ChunkReceived", "Eos" }, new[]{ "Detail" }, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.ByteStreamReaderChunkReceived), global::LiveKit.Proto.ByteStreamReaderChunkReceived.Parser, new[]{ "Content" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.ByteStreamReaderEOS), global::LiveKit.Proto.ByteStreamReaderEOS.Parser, new[]{ "Error" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.StreamSendFileRequest), global::LiveKit.Proto.StreamSendFileRequest.Parser, new[]{ "LocalParticipantHandle", "Options", "FilePath" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.StreamSendFileResponse), global::LiveKit.Proto.StreamSendFileResponse.Parser, new[]{ "AsyncId" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.StreamSendFileCallback), global::LiveKit.Proto.StreamSendFileCallback.Parser, new[]{ "AsyncId", "Info", "Error" }, new[]{ "Result" }, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.StreamSendTextRequest), global::LiveKit.Proto.StreamSendTextRequest.Parser, new[]{ "LocalParticipantHandle", "Options", "Text" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.StreamSendTextResponse), global::LiveKit.Proto.StreamSendTextResponse.Parser, new[]{ "AsyncId" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.StreamSendTextCallback), global::LiveKit.Proto.StreamSendTextCallback.Parser, new[]{ "AsyncId", "Info", "Error" }, new[]{ "Result" }, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.OwnedByteStreamWriter), global::LiveKit.Proto.OwnedByteStreamWriter.Parser, new[]{ "Handle", "Info" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.ByteStreamOpenRequest), global::LiveKit.Proto.ByteStreamOpenRequest.Parser, new[]{ "LocalParticipantHandle", "Options" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.ByteStreamOpenResponse), global::LiveKit.Proto.ByteStreamOpenResponse.Parser, new[]{ "AsyncId" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.ByteStreamOpenCallback), global::LiveKit.Proto.ByteStreamOpenCallback.Parser, new[]{ "AsyncId", "Writer", "Error" }, new[]{ "Result" }, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.ByteStreamWriterWriteRequest), global::LiveKit.Proto.ByteStreamWriterWriteRequest.Parser, new[]{ "WriterHandle", "Bytes" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.ByteStreamWriterWriteResponse), global::LiveKit.Proto.ByteStreamWriterWriteResponse.Parser, new[]{ "AsyncId" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.ByteStreamWriterWriteCallback), global::LiveKit.Proto.ByteStreamWriterWriteCallback.Parser, new[]{ "AsyncId", "Error" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.ByteStreamWriterCloseRequest), global::LiveKit.Proto.ByteStreamWriterCloseRequest.Parser, new[]{ "WriterHandle", "Reason" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.ByteStreamWriterCloseResponse), global::LiveKit.Proto.ByteStreamWriterCloseResponse.Parser, new[]{ "AsyncId" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.ByteStreamWriterCloseCallback), global::LiveKit.Proto.ByteStreamWriterCloseCallback.Parser, new[]{ "AsyncId", "Error" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.OwnedTextStreamWriter), global::LiveKit.Proto.OwnedTextStreamWriter.Parser, new[]{ "Handle", "Info" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.TextStreamOpenRequest), global::LiveKit.Proto.TextStreamOpenRequest.Parser, new[]{ "LocalParticipantHandle", "Options" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.TextStreamOpenResponse), global::LiveKit.Proto.TextStreamOpenResponse.Parser, new[]{ "AsyncId" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.TextStreamOpenCallback), global::LiveKit.Proto.TextStreamOpenCallback.Parser, new[]{ "AsyncId", "Writer", "Error" }, new[]{ "Result" }, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.TextStreamWriterWriteRequest), global::LiveKit.Proto.TextStreamWriterWriteRequest.Parser, new[]{ "WriterHandle", "Text" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.TextStreamWriterWriteResponse), global::LiveKit.Proto.TextStreamWriterWriteResponse.Parser, new[]{ "AsyncId" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.TextStreamWriterWriteCallback), global::LiveKit.Proto.TextStreamWriterWriteCallback.Parser, new[]{ "AsyncId", "Error" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.TextStreamWriterCloseRequest), global::LiveKit.Proto.TextStreamWriterCloseRequest.Parser, new[]{ "WriterHandle", "Reason" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.TextStreamWriterCloseResponse), global::LiveKit.Proto.TextStreamWriterCloseResponse.Parser, new[]{ "AsyncId" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.TextStreamWriterCloseCallback), global::LiveKit.Proto.TextStreamWriterCloseCallback.Parser, new[]{ "AsyncId", "Error" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.TextStreamInfo), global::LiveKit.Proto.TextStreamInfo.Parser, new[]{ "StreamId", "Timestamp", "MimeType", "Topic", "TotalLength", "Attributes", "OperationType", "Version", "ReplyToStreamId", "AttachedStreamIds", "Generated" }, null, new[]{ typeof(global::LiveKit.Proto.TextStreamInfo.Types.OperationType) }, null, new pbr::GeneratedClrTypeInfo[] { null, }), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.ByteStreamInfo), global::LiveKit.Proto.ByteStreamInfo.Parser, new[]{ "StreamId", "Timestamp", "MimeType", "Topic", "TotalLength", "Attributes", "Name" }, null, null, null, new pbr::GeneratedClrTypeInfo[] { null, }), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.StreamTextOptions), global::LiveKit.Proto.StreamTextOptions.Parser, new[]{ "Topic", "Attributes", "DestinationIdentities", "Id", "OperationType", "Version", "ReplyToStreamId", "AttachedStreamIds", "Generated" }, null, null, null, new pbr::GeneratedClrTypeInfo[] { null, }), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.StreamByteOptions), global::LiveKit.Proto.StreamByteOptions.Parser, new[]{ "Topic", "Attributes", "DestinationIdentities", "Id", "Name", "MimeType", "TotalLength" }, null, null, null, new pbr::GeneratedClrTypeInfo[] { null, }), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.StreamError), global::LiveKit.Proto.StreamError.Parser, new[]{ "Description" }, null, null, null, null) + })); + } + #endregion + + } + #region Messages + /// + /// A reader for an incoming stream. + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class OwnedTextStreamReader : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new OwnedTextStreamReader()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.DataStreamReflection.Descriptor.MessageTypes[0]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public OwnedTextStreamReader() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public OwnedTextStreamReader(OwnedTextStreamReader other) : this() { + handle_ = other.handle_ != null ? other.handle_.Clone() : null; + info_ = other.info_ != null ? other.info_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public OwnedTextStreamReader Clone() { + return new OwnedTextStreamReader(this); + } + + /// Field number for the "handle" field. + public const int HandleFieldNumber = 1; + private global::LiveKit.Proto.FfiOwnedHandle handle_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.FfiOwnedHandle Handle { + get { return handle_; } + set { + handle_ = value; + } + } + + /// Field number for the "info" field. + public const int InfoFieldNumber = 2; + private global::LiveKit.Proto.TextStreamInfo info_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.TextStreamInfo Info { + get { return info_; } + set { + info_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as OwnedTextStreamReader); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(OwnedTextStreamReader other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (!object.Equals(Handle, other.Handle)) return false; + if (!object.Equals(Info, other.Info)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (handle_ != null) hash ^= Handle.GetHashCode(); + if (info_ != null) hash ^= Info.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (handle_ != null) { + output.WriteRawTag(10); + output.WriteMessage(Handle); + } + if (info_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Info); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (handle_ != null) { + output.WriteRawTag(10); + output.WriteMessage(Handle); + } + if (info_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Info); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (handle_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Handle); + } + if (info_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Info); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(OwnedTextStreamReader other) { + if (other == null) { + return; + } + if (other.handle_ != null) { + if (handle_ == null) { + Handle = new global::LiveKit.Proto.FfiOwnedHandle(); + } + Handle.MergeFrom(other.Handle); + } + if (other.info_ != null) { + if (info_ == null) { + Info = new global::LiveKit.Proto.TextStreamInfo(); + } + Info.MergeFrom(other.Info); + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + if (handle_ == null) { + Handle = new global::LiveKit.Proto.FfiOwnedHandle(); + } + input.ReadMessage(Handle); + break; + } + case 18: { + if (info_ == null) { + Info = new global::LiveKit.Proto.TextStreamInfo(); + } + input.ReadMessage(Info); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + if (handle_ == null) { + Handle = new global::LiveKit.Proto.FfiOwnedHandle(); + } + input.ReadMessage(Handle); + break; + } + case 18: { + if (info_ == null) { + Info = new global::LiveKit.Proto.TextStreamInfo(); + } + input.ReadMessage(Info); + break; + } + } + } + } + #endif + + } + + /// + /// Reads an incoming text stream incrementally. + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class TextStreamReaderReadIncrementalRequest : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new TextStreamReaderReadIncrementalRequest()); + private pb::UnknownFieldSet _unknownFields; + private int _hasBits0; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.DataStreamReflection.Descriptor.MessageTypes[1]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TextStreamReaderReadIncrementalRequest() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TextStreamReaderReadIncrementalRequest(TextStreamReaderReadIncrementalRequest other) : this() { + _hasBits0 = other._hasBits0; + readerHandle_ = other.readerHandle_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TextStreamReaderReadIncrementalRequest Clone() { + return new TextStreamReaderReadIncrementalRequest(this); + } + + /// Field number for the "reader_handle" field. + public const int ReaderHandleFieldNumber = 1; + private readonly static ulong ReaderHandleDefaultValue = 0UL; + + private ulong readerHandle_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ulong ReaderHandle { + get { if ((_hasBits0 & 1) != 0) { return readerHandle_; } else { return ReaderHandleDefaultValue; } } + set { + _hasBits0 |= 1; + readerHandle_ = value; + } + } + /// Gets whether the "reader_handle" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasReaderHandle { + get { return (_hasBits0 & 1) != 0; } + } + /// Clears the value of the "reader_handle" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearReaderHandle() { + _hasBits0 &= ~1; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as TextStreamReaderReadIncrementalRequest); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(TextStreamReaderReadIncrementalRequest other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (ReaderHandle != other.ReaderHandle) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (HasReaderHandle) hash ^= ReaderHandle.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (HasReaderHandle) { + output.WriteRawTag(8); + output.WriteUInt64(ReaderHandle); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (HasReaderHandle) { + output.WriteRawTag(8); + output.WriteUInt64(ReaderHandle); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (HasReaderHandle) { + size += 1 + pb::CodedOutputStream.ComputeUInt64Size(ReaderHandle); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(TextStreamReaderReadIncrementalRequest other) { + if (other == null) { + return; + } + if (other.HasReaderHandle) { + ReaderHandle = other.ReaderHandle; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + ReaderHandle = input.ReadUInt64(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + ReaderHandle = input.ReadUInt64(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class TextStreamReaderReadIncrementalResponse : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new TextStreamReaderReadIncrementalResponse()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.DataStreamReflection.Descriptor.MessageTypes[2]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TextStreamReaderReadIncrementalResponse() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TextStreamReaderReadIncrementalResponse(TextStreamReaderReadIncrementalResponse other) : this() { + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TextStreamReaderReadIncrementalResponse Clone() { + return new TextStreamReaderReadIncrementalResponse(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as TextStreamReaderReadIncrementalResponse); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(TextStreamReaderReadIncrementalResponse other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(TextStreamReaderReadIncrementalResponse other) { + if (other == null) { + return; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + } + } + } + #endif + + } + + /// + /// Reads an incoming text stream in its entirety. + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class TextStreamReaderReadAllRequest : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new TextStreamReaderReadAllRequest()); + private pb::UnknownFieldSet _unknownFields; + private int _hasBits0; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.DataStreamReflection.Descriptor.MessageTypes[3]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TextStreamReaderReadAllRequest() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TextStreamReaderReadAllRequest(TextStreamReaderReadAllRequest other) : this() { + _hasBits0 = other._hasBits0; + readerHandle_ = other.readerHandle_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TextStreamReaderReadAllRequest Clone() { + return new TextStreamReaderReadAllRequest(this); + } + + /// Field number for the "reader_handle" field. + public const int ReaderHandleFieldNumber = 1; + private readonly static ulong ReaderHandleDefaultValue = 0UL; + + private ulong readerHandle_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ulong ReaderHandle { + get { if ((_hasBits0 & 1) != 0) { return readerHandle_; } else { return ReaderHandleDefaultValue; } } + set { + _hasBits0 |= 1; + readerHandle_ = value; + } + } + /// Gets whether the "reader_handle" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasReaderHandle { + get { return (_hasBits0 & 1) != 0; } + } + /// Clears the value of the "reader_handle" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearReaderHandle() { + _hasBits0 &= ~1; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as TextStreamReaderReadAllRequest); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(TextStreamReaderReadAllRequest other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (ReaderHandle != other.ReaderHandle) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (HasReaderHandle) hash ^= ReaderHandle.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (HasReaderHandle) { + output.WriteRawTag(8); + output.WriteUInt64(ReaderHandle); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (HasReaderHandle) { + output.WriteRawTag(8); + output.WriteUInt64(ReaderHandle); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (HasReaderHandle) { + size += 1 + pb::CodedOutputStream.ComputeUInt64Size(ReaderHandle); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(TextStreamReaderReadAllRequest other) { + if (other == null) { + return; + } + if (other.HasReaderHandle) { + ReaderHandle = other.ReaderHandle; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + ReaderHandle = input.ReadUInt64(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + ReaderHandle = input.ReadUInt64(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class TextStreamReaderReadAllResponse : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new TextStreamReaderReadAllResponse()); + private pb::UnknownFieldSet _unknownFields; + private int _hasBits0; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.DataStreamReflection.Descriptor.MessageTypes[4]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TextStreamReaderReadAllResponse() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TextStreamReaderReadAllResponse(TextStreamReaderReadAllResponse other) : this() { + _hasBits0 = other._hasBits0; + asyncId_ = other.asyncId_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TextStreamReaderReadAllResponse Clone() { + return new TextStreamReaderReadAllResponse(this); + } + + /// Field number for the "async_id" field. + public const int AsyncIdFieldNumber = 1; + private readonly static ulong AsyncIdDefaultValue = 0UL; + + private ulong asyncId_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ulong AsyncId { + get { if ((_hasBits0 & 1) != 0) { return asyncId_; } else { return AsyncIdDefaultValue; } } + set { + _hasBits0 |= 1; + asyncId_ = value; + } + } + /// Gets whether the "async_id" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasAsyncId { + get { return (_hasBits0 & 1) != 0; } + } + /// Clears the value of the "async_id" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearAsyncId() { + _hasBits0 &= ~1; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as TextStreamReaderReadAllResponse); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(TextStreamReaderReadAllResponse other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (AsyncId != other.AsyncId) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (HasAsyncId) hash ^= AsyncId.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (HasAsyncId) { + output.WriteRawTag(8); + output.WriteUInt64(AsyncId); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (HasAsyncId) { + output.WriteRawTag(8); + output.WriteUInt64(AsyncId); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (HasAsyncId) { + size += 1 + pb::CodedOutputStream.ComputeUInt64Size(AsyncId); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(TextStreamReaderReadAllResponse other) { + if (other == null) { + return; + } + if (other.HasAsyncId) { + AsyncId = other.AsyncId; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + AsyncId = input.ReadUInt64(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + AsyncId = input.ReadUInt64(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class TextStreamReaderReadAllCallback : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new TextStreamReaderReadAllCallback()); + private pb::UnknownFieldSet _unknownFields; + private int _hasBits0; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.DataStreamReflection.Descriptor.MessageTypes[5]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TextStreamReaderReadAllCallback() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TextStreamReaderReadAllCallback(TextStreamReaderReadAllCallback other) : this() { + _hasBits0 = other._hasBits0; + asyncId_ = other.asyncId_; + switch (other.ResultCase) { + case ResultOneofCase.Content: + Content = other.Content; + break; + case ResultOneofCase.Error: + Error = other.Error.Clone(); + break; + } + + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TextStreamReaderReadAllCallback Clone() { + return new TextStreamReaderReadAllCallback(this); + } + + /// Field number for the "async_id" field. + public const int AsyncIdFieldNumber = 1; + private readonly static ulong AsyncIdDefaultValue = 0UL; + + private ulong asyncId_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ulong AsyncId { + get { if ((_hasBits0 & 1) != 0) { return asyncId_; } else { return AsyncIdDefaultValue; } } + set { + _hasBits0 |= 1; + asyncId_ = value; + } + } + /// Gets whether the "async_id" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasAsyncId { + get { return (_hasBits0 & 1) != 0; } + } + /// Clears the value of the "async_id" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearAsyncId() { + _hasBits0 &= ~1; + } + + /// Field number for the "content" field. + public const int ContentFieldNumber = 2; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Content { + get { return HasContent ? (string) result_ : ""; } + set { + result_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + resultCase_ = ResultOneofCase.Content; + } + } + /// Gets whether the "content" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasContent { + get { return resultCase_ == ResultOneofCase.Content; } + } + /// Clears the value of the oneof if it's currently set to "content" + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearContent() { + if (HasContent) { + ClearResult(); + } + } + + /// Field number for the "error" field. + public const int ErrorFieldNumber = 3; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.StreamError Error { + get { return resultCase_ == ResultOneofCase.Error ? (global::LiveKit.Proto.StreamError) result_ : null; } + set { + result_ = value; + resultCase_ = value == null ? ResultOneofCase.None : ResultOneofCase.Error; + } + } + + private object result_; + /// Enum of possible cases for the "result" oneof. + public enum ResultOneofCase { + None = 0, + Content = 2, + Error = 3, + } + private ResultOneofCase resultCase_ = ResultOneofCase.None; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ResultOneofCase ResultCase { + get { return resultCase_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearResult() { + resultCase_ = ResultOneofCase.None; + result_ = null; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as TextStreamReaderReadAllCallback); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(TextStreamReaderReadAllCallback other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (AsyncId != other.AsyncId) return false; + if (Content != other.Content) return false; + if (!object.Equals(Error, other.Error)) return false; + if (ResultCase != other.ResultCase) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (HasAsyncId) hash ^= AsyncId.GetHashCode(); + if (HasContent) hash ^= Content.GetHashCode(); + if (resultCase_ == ResultOneofCase.Error) hash ^= Error.GetHashCode(); + hash ^= (int) resultCase_; + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (HasAsyncId) { + output.WriteRawTag(8); + output.WriteUInt64(AsyncId); + } + if (HasContent) { + output.WriteRawTag(18); + output.WriteString(Content); + } + if (resultCase_ == ResultOneofCase.Error) { + output.WriteRawTag(26); + output.WriteMessage(Error); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (HasAsyncId) { + output.WriteRawTag(8); + output.WriteUInt64(AsyncId); + } + if (HasContent) { + output.WriteRawTag(18); + output.WriteString(Content); + } + if (resultCase_ == ResultOneofCase.Error) { + output.WriteRawTag(26); + output.WriteMessage(Error); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (HasAsyncId) { + size += 1 + pb::CodedOutputStream.ComputeUInt64Size(AsyncId); + } + if (HasContent) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Content); + } + if (resultCase_ == ResultOneofCase.Error) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Error); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(TextStreamReaderReadAllCallback other) { + if (other == null) { + return; + } + if (other.HasAsyncId) { + AsyncId = other.AsyncId; + } + switch (other.ResultCase) { + case ResultOneofCase.Content: + Content = other.Content; + break; + case ResultOneofCase.Error: + if (Error == null) { + Error = new global::LiveKit.Proto.StreamError(); + } + Error.MergeFrom(other.Error); + break; + } + + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + AsyncId = input.ReadUInt64(); + break; + } + case 18: { + Content = input.ReadString(); + break; + } + case 26: { + global::LiveKit.Proto.StreamError subBuilder = new global::LiveKit.Proto.StreamError(); + if (resultCase_ == ResultOneofCase.Error) { + subBuilder.MergeFrom(Error); + } + input.ReadMessage(subBuilder); + Error = subBuilder; + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + AsyncId = input.ReadUInt64(); + break; + } + case 18: { + Content = input.ReadString(); + break; + } + case 26: { + global::LiveKit.Proto.StreamError subBuilder = new global::LiveKit.Proto.StreamError(); + if (resultCase_ == ResultOneofCase.Error) { + subBuilder.MergeFrom(Error); + } + input.ReadMessage(subBuilder); + Error = subBuilder; + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class TextStreamReaderEvent : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new TextStreamReaderEvent()); + private pb::UnknownFieldSet _unknownFields; + private int _hasBits0; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.DataStreamReflection.Descriptor.MessageTypes[6]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TextStreamReaderEvent() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TextStreamReaderEvent(TextStreamReaderEvent other) : this() { + _hasBits0 = other._hasBits0; + readerHandle_ = other.readerHandle_; + switch (other.DetailCase) { + case DetailOneofCase.ChunkReceived: + ChunkReceived = other.ChunkReceived.Clone(); + break; + case DetailOneofCase.Eos: + Eos = other.Eos.Clone(); + break; + } + + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TextStreamReaderEvent Clone() { + return new TextStreamReaderEvent(this); + } + + /// Field number for the "reader_handle" field. + public const int ReaderHandleFieldNumber = 1; + private readonly static ulong ReaderHandleDefaultValue = 0UL; + + private ulong readerHandle_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ulong ReaderHandle { + get { if ((_hasBits0 & 1) != 0) { return readerHandle_; } else { return ReaderHandleDefaultValue; } } + set { + _hasBits0 |= 1; + readerHandle_ = value; + } + } + /// Gets whether the "reader_handle" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasReaderHandle { + get { return (_hasBits0 & 1) != 0; } + } + /// Clears the value of the "reader_handle" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearReaderHandle() { + _hasBits0 &= ~1; + } + + /// Field number for the "chunk_received" field. + public const int ChunkReceivedFieldNumber = 2; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.TextStreamReaderChunkReceived ChunkReceived { + get { return detailCase_ == DetailOneofCase.ChunkReceived ? (global::LiveKit.Proto.TextStreamReaderChunkReceived) detail_ : null; } + set { + detail_ = value; + detailCase_ = value == null ? DetailOneofCase.None : DetailOneofCase.ChunkReceived; + } + } + + /// Field number for the "eos" field. + public const int EosFieldNumber = 3; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.TextStreamReaderEOS Eos { + get { return detailCase_ == DetailOneofCase.Eos ? (global::LiveKit.Proto.TextStreamReaderEOS) detail_ : null; } + set { + detail_ = value; + detailCase_ = value == null ? DetailOneofCase.None : DetailOneofCase.Eos; + } + } + + private object detail_; + /// Enum of possible cases for the "detail" oneof. + public enum DetailOneofCase { + None = 0, + ChunkReceived = 2, + Eos = 3, + } + private DetailOneofCase detailCase_ = DetailOneofCase.None; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public DetailOneofCase DetailCase { + get { return detailCase_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearDetail() { + detailCase_ = DetailOneofCase.None; + detail_ = null; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as TextStreamReaderEvent); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(TextStreamReaderEvent other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (ReaderHandle != other.ReaderHandle) return false; + if (!object.Equals(ChunkReceived, other.ChunkReceived)) return false; + if (!object.Equals(Eos, other.Eos)) return false; + if (DetailCase != other.DetailCase) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (HasReaderHandle) hash ^= ReaderHandle.GetHashCode(); + if (detailCase_ == DetailOneofCase.ChunkReceived) hash ^= ChunkReceived.GetHashCode(); + if (detailCase_ == DetailOneofCase.Eos) hash ^= Eos.GetHashCode(); + hash ^= (int) detailCase_; + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (HasReaderHandle) { + output.WriteRawTag(8); + output.WriteUInt64(ReaderHandle); + } + if (detailCase_ == DetailOneofCase.ChunkReceived) { + output.WriteRawTag(18); + output.WriteMessage(ChunkReceived); + } + if (detailCase_ == DetailOneofCase.Eos) { + output.WriteRawTag(26); + output.WriteMessage(Eos); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (HasReaderHandle) { + output.WriteRawTag(8); + output.WriteUInt64(ReaderHandle); + } + if (detailCase_ == DetailOneofCase.ChunkReceived) { + output.WriteRawTag(18); + output.WriteMessage(ChunkReceived); + } + if (detailCase_ == DetailOneofCase.Eos) { + output.WriteRawTag(26); + output.WriteMessage(Eos); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (HasReaderHandle) { + size += 1 + pb::CodedOutputStream.ComputeUInt64Size(ReaderHandle); + } + if (detailCase_ == DetailOneofCase.ChunkReceived) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(ChunkReceived); + } + if (detailCase_ == DetailOneofCase.Eos) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Eos); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(TextStreamReaderEvent other) { + if (other == null) { + return; + } + if (other.HasReaderHandle) { + ReaderHandle = other.ReaderHandle; + } + switch (other.DetailCase) { + case DetailOneofCase.ChunkReceived: + if (ChunkReceived == null) { + ChunkReceived = new global::LiveKit.Proto.TextStreamReaderChunkReceived(); + } + ChunkReceived.MergeFrom(other.ChunkReceived); + break; + case DetailOneofCase.Eos: + if (Eos == null) { + Eos = new global::LiveKit.Proto.TextStreamReaderEOS(); + } + Eos.MergeFrom(other.Eos); + break; + } + + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + ReaderHandle = input.ReadUInt64(); + break; + } + case 18: { + global::LiveKit.Proto.TextStreamReaderChunkReceived subBuilder = new global::LiveKit.Proto.TextStreamReaderChunkReceived(); + if (detailCase_ == DetailOneofCase.ChunkReceived) { + subBuilder.MergeFrom(ChunkReceived); + } + input.ReadMessage(subBuilder); + ChunkReceived = subBuilder; + break; + } + case 26: { + global::LiveKit.Proto.TextStreamReaderEOS subBuilder = new global::LiveKit.Proto.TextStreamReaderEOS(); + if (detailCase_ == DetailOneofCase.Eos) { + subBuilder.MergeFrom(Eos); + } + input.ReadMessage(subBuilder); + Eos = subBuilder; + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + ReaderHandle = input.ReadUInt64(); + break; + } + case 18: { + global::LiveKit.Proto.TextStreamReaderChunkReceived subBuilder = new global::LiveKit.Proto.TextStreamReaderChunkReceived(); + if (detailCase_ == DetailOneofCase.ChunkReceived) { + subBuilder.MergeFrom(ChunkReceived); + } + input.ReadMessage(subBuilder); + ChunkReceived = subBuilder; + break; + } + case 26: { + global::LiveKit.Proto.TextStreamReaderEOS subBuilder = new global::LiveKit.Proto.TextStreamReaderEOS(); + if (detailCase_ == DetailOneofCase.Eos) { + subBuilder.MergeFrom(Eos); + } + input.ReadMessage(subBuilder); + Eos = subBuilder; + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class TextStreamReaderChunkReceived : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new TextStreamReaderChunkReceived()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.DataStreamReflection.Descriptor.MessageTypes[7]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TextStreamReaderChunkReceived() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TextStreamReaderChunkReceived(TextStreamReaderChunkReceived other) : this() { + content_ = other.content_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TextStreamReaderChunkReceived Clone() { + return new TextStreamReaderChunkReceived(this); + } + + /// Field number for the "content" field. + public const int ContentFieldNumber = 1; + private readonly static string ContentDefaultValue = ""; + + private string content_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Content { + get { return content_ ?? ContentDefaultValue; } + set { + content_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + /// Gets whether the "content" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasContent { + get { return content_ != null; } + } + /// Clears the value of the "content" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearContent() { + content_ = null; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as TextStreamReaderChunkReceived); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(TextStreamReaderChunkReceived other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Content != other.Content) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (HasContent) hash ^= Content.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (HasContent) { + output.WriteRawTag(10); + output.WriteString(Content); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (HasContent) { + output.WriteRawTag(10); + output.WriteString(Content); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (HasContent) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Content); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(TextStreamReaderChunkReceived other) { + if (other == null) { + return; + } + if (other.HasContent) { + Content = other.Content; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + Content = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + Content = input.ReadString(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class TextStreamReaderEOS : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new TextStreamReaderEOS()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.DataStreamReflection.Descriptor.MessageTypes[8]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TextStreamReaderEOS() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TextStreamReaderEOS(TextStreamReaderEOS other) : this() { + error_ = other.error_ != null ? other.error_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TextStreamReaderEOS Clone() { + return new TextStreamReaderEOS(this); + } + + /// Field number for the "error" field. + public const int ErrorFieldNumber = 1; + private global::LiveKit.Proto.StreamError error_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.StreamError Error { + get { return error_; } + set { + error_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as TextStreamReaderEOS); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(TextStreamReaderEOS other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (!object.Equals(Error, other.Error)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (error_ != null) hash ^= Error.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (error_ != null) { + output.WriteRawTag(10); + output.WriteMessage(Error); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (error_ != null) { + output.WriteRawTag(10); + output.WriteMessage(Error); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (error_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Error); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(TextStreamReaderEOS other) { + if (other == null) { + return; + } + if (other.error_ != null) { + if (error_ == null) { + Error = new global::LiveKit.Proto.StreamError(); + } + Error.MergeFrom(other.Error); + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + if (error_ == null) { + Error = new global::LiveKit.Proto.StreamError(); + } + input.ReadMessage(Error); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + if (error_ == null) { + Error = new global::LiveKit.Proto.StreamError(); + } + input.ReadMessage(Error); + break; + } + } + } + } + #endif + + } + + /// + /// A reader for an incoming stream. + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class OwnedByteStreamReader : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new OwnedByteStreamReader()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.DataStreamReflection.Descriptor.MessageTypes[9]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public OwnedByteStreamReader() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public OwnedByteStreamReader(OwnedByteStreamReader other) : this() { + handle_ = other.handle_ != null ? other.handle_.Clone() : null; + info_ = other.info_ != null ? other.info_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public OwnedByteStreamReader Clone() { + return new OwnedByteStreamReader(this); + } + + /// Field number for the "handle" field. + public const int HandleFieldNumber = 1; + private global::LiveKit.Proto.FfiOwnedHandle handle_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.FfiOwnedHandle Handle { + get { return handle_; } + set { + handle_ = value; + } + } + + /// Field number for the "info" field. + public const int InfoFieldNumber = 2; + private global::LiveKit.Proto.ByteStreamInfo info_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.ByteStreamInfo Info { + get { return info_; } + set { + info_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as OwnedByteStreamReader); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(OwnedByteStreamReader other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (!object.Equals(Handle, other.Handle)) return false; + if (!object.Equals(Info, other.Info)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (handle_ != null) hash ^= Handle.GetHashCode(); + if (info_ != null) hash ^= Info.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (handle_ != null) { + output.WriteRawTag(10); + output.WriteMessage(Handle); + } + if (info_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Info); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (handle_ != null) { + output.WriteRawTag(10); + output.WriteMessage(Handle); + } + if (info_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Info); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (handle_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Handle); + } + if (info_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Info); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(OwnedByteStreamReader other) { + if (other == null) { + return; + } + if (other.handle_ != null) { + if (handle_ == null) { + Handle = new global::LiveKit.Proto.FfiOwnedHandle(); + } + Handle.MergeFrom(other.Handle); + } + if (other.info_ != null) { + if (info_ == null) { + Info = new global::LiveKit.Proto.ByteStreamInfo(); + } + Info.MergeFrom(other.Info); + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + if (handle_ == null) { + Handle = new global::LiveKit.Proto.FfiOwnedHandle(); + } + input.ReadMessage(Handle); + break; + } + case 18: { + if (info_ == null) { + Info = new global::LiveKit.Proto.ByteStreamInfo(); + } + input.ReadMessage(Info); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + if (handle_ == null) { + Handle = new global::LiveKit.Proto.FfiOwnedHandle(); + } + input.ReadMessage(Handle); + break; + } + case 18: { + if (info_ == null) { + Info = new global::LiveKit.Proto.ByteStreamInfo(); + } + input.ReadMessage(Info); + break; + } + } + } + } + #endif + + } + + /// + /// Reads an incoming byte stream incrementally. + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class ByteStreamReaderReadIncrementalRequest : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ByteStreamReaderReadIncrementalRequest()); + private pb::UnknownFieldSet _unknownFields; + private int _hasBits0; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.DataStreamReflection.Descriptor.MessageTypes[10]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ByteStreamReaderReadIncrementalRequest() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ByteStreamReaderReadIncrementalRequest(ByteStreamReaderReadIncrementalRequest other) : this() { + _hasBits0 = other._hasBits0; + readerHandle_ = other.readerHandle_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ByteStreamReaderReadIncrementalRequest Clone() { + return new ByteStreamReaderReadIncrementalRequest(this); + } + + /// Field number for the "reader_handle" field. + public const int ReaderHandleFieldNumber = 1; + private readonly static ulong ReaderHandleDefaultValue = 0UL; + + private ulong readerHandle_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ulong ReaderHandle { + get { if ((_hasBits0 & 1) != 0) { return readerHandle_; } else { return ReaderHandleDefaultValue; } } + set { + _hasBits0 |= 1; + readerHandle_ = value; + } + } + /// Gets whether the "reader_handle" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasReaderHandle { + get { return (_hasBits0 & 1) != 0; } + } + /// Clears the value of the "reader_handle" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearReaderHandle() { + _hasBits0 &= ~1; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as ByteStreamReaderReadIncrementalRequest); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(ByteStreamReaderReadIncrementalRequest other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (ReaderHandle != other.ReaderHandle) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (HasReaderHandle) hash ^= ReaderHandle.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (HasReaderHandle) { + output.WriteRawTag(8); + output.WriteUInt64(ReaderHandle); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (HasReaderHandle) { + output.WriteRawTag(8); + output.WriteUInt64(ReaderHandle); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (HasReaderHandle) { + size += 1 + pb::CodedOutputStream.ComputeUInt64Size(ReaderHandle); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(ByteStreamReaderReadIncrementalRequest other) { + if (other == null) { + return; + } + if (other.HasReaderHandle) { + ReaderHandle = other.ReaderHandle; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + ReaderHandle = input.ReadUInt64(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + ReaderHandle = input.ReadUInt64(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class ByteStreamReaderReadIncrementalResponse : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ByteStreamReaderReadIncrementalResponse()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.DataStreamReflection.Descriptor.MessageTypes[11]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ByteStreamReaderReadIncrementalResponse() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ByteStreamReaderReadIncrementalResponse(ByteStreamReaderReadIncrementalResponse other) : this() { + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ByteStreamReaderReadIncrementalResponse Clone() { + return new ByteStreamReaderReadIncrementalResponse(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as ByteStreamReaderReadIncrementalResponse); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(ByteStreamReaderReadIncrementalResponse other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(ByteStreamReaderReadIncrementalResponse other) { + if (other == null) { + return; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + } + } + } + #endif + + } + + /// + /// Reads an incoming byte stream in its entirety. + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class ByteStreamReaderReadAllRequest : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ByteStreamReaderReadAllRequest()); + private pb::UnknownFieldSet _unknownFields; + private int _hasBits0; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.DataStreamReflection.Descriptor.MessageTypes[12]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ByteStreamReaderReadAllRequest() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ByteStreamReaderReadAllRequest(ByteStreamReaderReadAllRequest other) : this() { + _hasBits0 = other._hasBits0; + readerHandle_ = other.readerHandle_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ByteStreamReaderReadAllRequest Clone() { + return new ByteStreamReaderReadAllRequest(this); + } + + /// Field number for the "reader_handle" field. + public const int ReaderHandleFieldNumber = 1; + private readonly static ulong ReaderHandleDefaultValue = 0UL; + + private ulong readerHandle_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ulong ReaderHandle { + get { if ((_hasBits0 & 1) != 0) { return readerHandle_; } else { return ReaderHandleDefaultValue; } } + set { + _hasBits0 |= 1; + readerHandle_ = value; + } + } + /// Gets whether the "reader_handle" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasReaderHandle { + get { return (_hasBits0 & 1) != 0; } + } + /// Clears the value of the "reader_handle" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearReaderHandle() { + _hasBits0 &= ~1; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as ByteStreamReaderReadAllRequest); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(ByteStreamReaderReadAllRequest other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (ReaderHandle != other.ReaderHandle) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (HasReaderHandle) hash ^= ReaderHandle.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (HasReaderHandle) { + output.WriteRawTag(8); + output.WriteUInt64(ReaderHandle); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (HasReaderHandle) { + output.WriteRawTag(8); + output.WriteUInt64(ReaderHandle); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (HasReaderHandle) { + size += 1 + pb::CodedOutputStream.ComputeUInt64Size(ReaderHandle); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(ByteStreamReaderReadAllRequest other) { + if (other == null) { + return; + } + if (other.HasReaderHandle) { + ReaderHandle = other.ReaderHandle; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + ReaderHandle = input.ReadUInt64(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + ReaderHandle = input.ReadUInt64(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class ByteStreamReaderReadAllResponse : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ByteStreamReaderReadAllResponse()); + private pb::UnknownFieldSet _unknownFields; + private int _hasBits0; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.DataStreamReflection.Descriptor.MessageTypes[13]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ByteStreamReaderReadAllResponse() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ByteStreamReaderReadAllResponse(ByteStreamReaderReadAllResponse other) : this() { + _hasBits0 = other._hasBits0; + asyncId_ = other.asyncId_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ByteStreamReaderReadAllResponse Clone() { + return new ByteStreamReaderReadAllResponse(this); + } + + /// Field number for the "async_id" field. + public const int AsyncIdFieldNumber = 1; + private readonly static ulong AsyncIdDefaultValue = 0UL; + + private ulong asyncId_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ulong AsyncId { + get { if ((_hasBits0 & 1) != 0) { return asyncId_; } else { return AsyncIdDefaultValue; } } + set { + _hasBits0 |= 1; + asyncId_ = value; + } + } + /// Gets whether the "async_id" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasAsyncId { + get { return (_hasBits0 & 1) != 0; } + } + /// Clears the value of the "async_id" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearAsyncId() { + _hasBits0 &= ~1; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as ByteStreamReaderReadAllResponse); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(ByteStreamReaderReadAllResponse other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (AsyncId != other.AsyncId) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (HasAsyncId) hash ^= AsyncId.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (HasAsyncId) { + output.WriteRawTag(8); + output.WriteUInt64(AsyncId); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (HasAsyncId) { + output.WriteRawTag(8); + output.WriteUInt64(AsyncId); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (HasAsyncId) { + size += 1 + pb::CodedOutputStream.ComputeUInt64Size(AsyncId); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(ByteStreamReaderReadAllResponse other) { + if (other == null) { + return; + } + if (other.HasAsyncId) { + AsyncId = other.AsyncId; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + AsyncId = input.ReadUInt64(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + AsyncId = input.ReadUInt64(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class ByteStreamReaderReadAllCallback : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ByteStreamReaderReadAllCallback()); + private pb::UnknownFieldSet _unknownFields; + private int _hasBits0; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.DataStreamReflection.Descriptor.MessageTypes[14]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ByteStreamReaderReadAllCallback() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ByteStreamReaderReadAllCallback(ByteStreamReaderReadAllCallback other) : this() { + _hasBits0 = other._hasBits0; + asyncId_ = other.asyncId_; + switch (other.ResultCase) { + case ResultOneofCase.Content: + Content = other.Content; + break; + case ResultOneofCase.Error: + Error = other.Error.Clone(); + break; + } + + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ByteStreamReaderReadAllCallback Clone() { + return new ByteStreamReaderReadAllCallback(this); + } + + /// Field number for the "async_id" field. + public const int AsyncIdFieldNumber = 1; + private readonly static ulong AsyncIdDefaultValue = 0UL; + + private ulong asyncId_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ulong AsyncId { + get { if ((_hasBits0 & 1) != 0) { return asyncId_; } else { return AsyncIdDefaultValue; } } + set { + _hasBits0 |= 1; + asyncId_ = value; + } + } + /// Gets whether the "async_id" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasAsyncId { + get { return (_hasBits0 & 1) != 0; } + } + /// Clears the value of the "async_id" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearAsyncId() { + _hasBits0 &= ~1; + } + + /// Field number for the "content" field. + public const int ContentFieldNumber = 2; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pb::ByteString Content { + get { return HasContent ? (pb::ByteString) result_ : pb::ByteString.Empty; } + set { + result_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + resultCase_ = ResultOneofCase.Content; + } + } + /// Gets whether the "content" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasContent { + get { return resultCase_ == ResultOneofCase.Content; } + } + /// Clears the value of the oneof if it's currently set to "content" + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearContent() { + if (HasContent) { + ClearResult(); + } + } + + /// Field number for the "error" field. + public const int ErrorFieldNumber = 3; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.StreamError Error { + get { return resultCase_ == ResultOneofCase.Error ? (global::LiveKit.Proto.StreamError) result_ : null; } + set { + result_ = value; + resultCase_ = value == null ? ResultOneofCase.None : ResultOneofCase.Error; + } + } + + private object result_; + /// Enum of possible cases for the "result" oneof. + public enum ResultOneofCase { + None = 0, + Content = 2, + Error = 3, + } + private ResultOneofCase resultCase_ = ResultOneofCase.None; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ResultOneofCase ResultCase { + get { return resultCase_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearResult() { + resultCase_ = ResultOneofCase.None; + result_ = null; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as ByteStreamReaderReadAllCallback); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(ByteStreamReaderReadAllCallback other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (AsyncId != other.AsyncId) return false; + if (Content != other.Content) return false; + if (!object.Equals(Error, other.Error)) return false; + if (ResultCase != other.ResultCase) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (HasAsyncId) hash ^= AsyncId.GetHashCode(); + if (HasContent) hash ^= Content.GetHashCode(); + if (resultCase_ == ResultOneofCase.Error) hash ^= Error.GetHashCode(); + hash ^= (int) resultCase_; + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (HasAsyncId) { + output.WriteRawTag(8); + output.WriteUInt64(AsyncId); + } + if (HasContent) { + output.WriteRawTag(18); + output.WriteBytes(Content); + } + if (resultCase_ == ResultOneofCase.Error) { + output.WriteRawTag(26); + output.WriteMessage(Error); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (HasAsyncId) { + output.WriteRawTag(8); + output.WriteUInt64(AsyncId); + } + if (HasContent) { + output.WriteRawTag(18); + output.WriteBytes(Content); + } + if (resultCase_ == ResultOneofCase.Error) { + output.WriteRawTag(26); + output.WriteMessage(Error); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (HasAsyncId) { + size += 1 + pb::CodedOutputStream.ComputeUInt64Size(AsyncId); + } + if (HasContent) { + size += 1 + pb::CodedOutputStream.ComputeBytesSize(Content); + } + if (resultCase_ == ResultOneofCase.Error) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Error); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(ByteStreamReaderReadAllCallback other) { + if (other == null) { + return; + } + if (other.HasAsyncId) { + AsyncId = other.AsyncId; + } + switch (other.ResultCase) { + case ResultOneofCase.Content: + Content = other.Content; + break; + case ResultOneofCase.Error: + if (Error == null) { + Error = new global::LiveKit.Proto.StreamError(); + } + Error.MergeFrom(other.Error); + break; + } + + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + AsyncId = input.ReadUInt64(); + break; + } + case 18: { + Content = input.ReadBytes(); + break; + } + case 26: { + global::LiveKit.Proto.StreamError subBuilder = new global::LiveKit.Proto.StreamError(); + if (resultCase_ == ResultOneofCase.Error) { + subBuilder.MergeFrom(Error); + } + input.ReadMessage(subBuilder); + Error = subBuilder; + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + AsyncId = input.ReadUInt64(); + break; + } + case 18: { + Content = input.ReadBytes(); + break; + } + case 26: { + global::LiveKit.Proto.StreamError subBuilder = new global::LiveKit.Proto.StreamError(); + if (resultCase_ == ResultOneofCase.Error) { + subBuilder.MergeFrom(Error); + } + input.ReadMessage(subBuilder); + Error = subBuilder; + break; + } + } + } + } + #endif + + } + + /// + /// Writes data from an incoming stream to a file as it arrives. + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class ByteStreamReaderWriteToFileRequest : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ByteStreamReaderWriteToFileRequest()); + private pb::UnknownFieldSet _unknownFields; + private int _hasBits0; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.DataStreamReflection.Descriptor.MessageTypes[15]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ByteStreamReaderWriteToFileRequest() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ByteStreamReaderWriteToFileRequest(ByteStreamReaderWriteToFileRequest other) : this() { + _hasBits0 = other._hasBits0; + readerHandle_ = other.readerHandle_; + directory_ = other.directory_; + nameOverride_ = other.nameOverride_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ByteStreamReaderWriteToFileRequest Clone() { + return new ByteStreamReaderWriteToFileRequest(this); + } + + /// Field number for the "reader_handle" field. + public const int ReaderHandleFieldNumber = 1; + private readonly static ulong ReaderHandleDefaultValue = 0UL; + + private ulong readerHandle_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ulong ReaderHandle { + get { if ((_hasBits0 & 1) != 0) { return readerHandle_; } else { return ReaderHandleDefaultValue; } } + set { + _hasBits0 |= 1; + readerHandle_ = value; + } + } + /// Gets whether the "reader_handle" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasReaderHandle { + get { return (_hasBits0 & 1) != 0; } + } + /// Clears the value of the "reader_handle" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearReaderHandle() { + _hasBits0 &= ~1; + } + + /// Field number for the "directory" field. + public const int DirectoryFieldNumber = 3; + private readonly static string DirectoryDefaultValue = ""; + + private string directory_; + /// + /// Directory to write the file in (must be writable by the current process). + /// If not provided, the file will be written to the system's temp directory. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Directory { + get { return directory_ ?? DirectoryDefaultValue; } + set { + directory_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + /// Gets whether the "directory" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasDirectory { + get { return directory_ != null; } + } + /// Clears the value of the "directory" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearDirectory() { + directory_ = null; + } + + /// Field number for the "name_override" field. + public const int NameOverrideFieldNumber = 4; + private readonly static string NameOverrideDefaultValue = ""; + + private string nameOverride_; + /// + /// Name to use for the written file. + /// If not provided, the file's name and extension will be inferred from + /// the stream's info. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string NameOverride { + get { return nameOverride_ ?? NameOverrideDefaultValue; } + set { + nameOverride_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + /// Gets whether the "name_override" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasNameOverride { + get { return nameOverride_ != null; } + } + /// Clears the value of the "name_override" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearNameOverride() { + nameOverride_ = null; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as ByteStreamReaderWriteToFileRequest); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(ByteStreamReaderWriteToFileRequest other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (ReaderHandle != other.ReaderHandle) return false; + if (Directory != other.Directory) return false; + if (NameOverride != other.NameOverride) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (HasReaderHandle) hash ^= ReaderHandle.GetHashCode(); + if (HasDirectory) hash ^= Directory.GetHashCode(); + if (HasNameOverride) hash ^= NameOverride.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (HasReaderHandle) { + output.WriteRawTag(8); + output.WriteUInt64(ReaderHandle); + } + if (HasDirectory) { + output.WriteRawTag(26); + output.WriteString(Directory); + } + if (HasNameOverride) { + output.WriteRawTag(34); + output.WriteString(NameOverride); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (HasReaderHandle) { + output.WriteRawTag(8); + output.WriteUInt64(ReaderHandle); + } + if (HasDirectory) { + output.WriteRawTag(26); + output.WriteString(Directory); + } + if (HasNameOverride) { + output.WriteRawTag(34); + output.WriteString(NameOverride); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (HasReaderHandle) { + size += 1 + pb::CodedOutputStream.ComputeUInt64Size(ReaderHandle); + } + if (HasDirectory) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Directory); + } + if (HasNameOverride) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(NameOverride); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(ByteStreamReaderWriteToFileRequest other) { + if (other == null) { + return; + } + if (other.HasReaderHandle) { + ReaderHandle = other.ReaderHandle; + } + if (other.HasDirectory) { + Directory = other.Directory; + } + if (other.HasNameOverride) { + NameOverride = other.NameOverride; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + ReaderHandle = input.ReadUInt64(); + break; + } + case 26: { + Directory = input.ReadString(); + break; + } + case 34: { + NameOverride = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + ReaderHandle = input.ReadUInt64(); + break; + } + case 26: { + Directory = input.ReadString(); + break; + } + case 34: { + NameOverride = input.ReadString(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class ByteStreamReaderWriteToFileResponse : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ByteStreamReaderWriteToFileResponse()); + private pb::UnknownFieldSet _unknownFields; + private int _hasBits0; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.DataStreamReflection.Descriptor.MessageTypes[16]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ByteStreamReaderWriteToFileResponse() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ByteStreamReaderWriteToFileResponse(ByteStreamReaderWriteToFileResponse other) : this() { + _hasBits0 = other._hasBits0; + asyncId_ = other.asyncId_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ByteStreamReaderWriteToFileResponse Clone() { + return new ByteStreamReaderWriteToFileResponse(this); + } + + /// Field number for the "async_id" field. + public const int AsyncIdFieldNumber = 1; + private readonly static ulong AsyncIdDefaultValue = 0UL; + + private ulong asyncId_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ulong AsyncId { + get { if ((_hasBits0 & 1) != 0) { return asyncId_; } else { return AsyncIdDefaultValue; } } + set { + _hasBits0 |= 1; + asyncId_ = value; + } + } + /// Gets whether the "async_id" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasAsyncId { + get { return (_hasBits0 & 1) != 0; } + } + /// Clears the value of the "async_id" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearAsyncId() { + _hasBits0 &= ~1; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as ByteStreamReaderWriteToFileResponse); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(ByteStreamReaderWriteToFileResponse other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (AsyncId != other.AsyncId) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (HasAsyncId) hash ^= AsyncId.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (HasAsyncId) { + output.WriteRawTag(8); + output.WriteUInt64(AsyncId); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (HasAsyncId) { + output.WriteRawTag(8); + output.WriteUInt64(AsyncId); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (HasAsyncId) { + size += 1 + pb::CodedOutputStream.ComputeUInt64Size(AsyncId); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(ByteStreamReaderWriteToFileResponse other) { + if (other == null) { + return; + } + if (other.HasAsyncId) { + AsyncId = other.AsyncId; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + AsyncId = input.ReadUInt64(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + AsyncId = input.ReadUInt64(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class ByteStreamReaderWriteToFileCallback : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ByteStreamReaderWriteToFileCallback()); + private pb::UnknownFieldSet _unknownFields; + private int _hasBits0; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.DataStreamReflection.Descriptor.MessageTypes[17]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ByteStreamReaderWriteToFileCallback() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ByteStreamReaderWriteToFileCallback(ByteStreamReaderWriteToFileCallback other) : this() { + _hasBits0 = other._hasBits0; + asyncId_ = other.asyncId_; + switch (other.ResultCase) { + case ResultOneofCase.FilePath: + FilePath = other.FilePath; + break; + case ResultOneofCase.Error: + Error = other.Error.Clone(); + break; + } + + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ByteStreamReaderWriteToFileCallback Clone() { + return new ByteStreamReaderWriteToFileCallback(this); + } + + /// Field number for the "async_id" field. + public const int AsyncIdFieldNumber = 1; + private readonly static ulong AsyncIdDefaultValue = 0UL; + + private ulong asyncId_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ulong AsyncId { + get { if ((_hasBits0 & 1) != 0) { return asyncId_; } else { return AsyncIdDefaultValue; } } + set { + _hasBits0 |= 1; + asyncId_ = value; + } + } + /// Gets whether the "async_id" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasAsyncId { + get { return (_hasBits0 & 1) != 0; } + } + /// Clears the value of the "async_id" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearAsyncId() { + _hasBits0 &= ~1; + } + + /// Field number for the "file_path" field. + public const int FilePathFieldNumber = 2; + /// + /// Path the file was written to. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string FilePath { + get { return HasFilePath ? (string) result_ : ""; } + set { + result_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + resultCase_ = ResultOneofCase.FilePath; + } + } + /// Gets whether the "file_path" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasFilePath { + get { return resultCase_ == ResultOneofCase.FilePath; } + } + /// Clears the value of the oneof if it's currently set to "file_path" + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearFilePath() { + if (HasFilePath) { + ClearResult(); + } + } + + /// Field number for the "error" field. + public const int ErrorFieldNumber = 3; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.StreamError Error { + get { return resultCase_ == ResultOneofCase.Error ? (global::LiveKit.Proto.StreamError) result_ : null; } + set { + result_ = value; + resultCase_ = value == null ? ResultOneofCase.None : ResultOneofCase.Error; + } + } + + private object result_; + /// Enum of possible cases for the "result" oneof. + public enum ResultOneofCase { + None = 0, + FilePath = 2, + Error = 3, + } + private ResultOneofCase resultCase_ = ResultOneofCase.None; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ResultOneofCase ResultCase { + get { return resultCase_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearResult() { + resultCase_ = ResultOneofCase.None; + result_ = null; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as ByteStreamReaderWriteToFileCallback); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(ByteStreamReaderWriteToFileCallback other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (AsyncId != other.AsyncId) return false; + if (FilePath != other.FilePath) return false; + if (!object.Equals(Error, other.Error)) return false; + if (ResultCase != other.ResultCase) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (HasAsyncId) hash ^= AsyncId.GetHashCode(); + if (HasFilePath) hash ^= FilePath.GetHashCode(); + if (resultCase_ == ResultOneofCase.Error) hash ^= Error.GetHashCode(); + hash ^= (int) resultCase_; + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (HasAsyncId) { + output.WriteRawTag(8); + output.WriteUInt64(AsyncId); + } + if (HasFilePath) { + output.WriteRawTag(18); + output.WriteString(FilePath); + } + if (resultCase_ == ResultOneofCase.Error) { + output.WriteRawTag(26); + output.WriteMessage(Error); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (HasAsyncId) { + output.WriteRawTag(8); + output.WriteUInt64(AsyncId); + } + if (HasFilePath) { + output.WriteRawTag(18); + output.WriteString(FilePath); + } + if (resultCase_ == ResultOneofCase.Error) { + output.WriteRawTag(26); + output.WriteMessage(Error); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (HasAsyncId) { + size += 1 + pb::CodedOutputStream.ComputeUInt64Size(AsyncId); + } + if (HasFilePath) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(FilePath); + } + if (resultCase_ == ResultOneofCase.Error) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Error); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(ByteStreamReaderWriteToFileCallback other) { + if (other == null) { + return; + } + if (other.HasAsyncId) { + AsyncId = other.AsyncId; + } + switch (other.ResultCase) { + case ResultOneofCase.FilePath: + FilePath = other.FilePath; + break; + case ResultOneofCase.Error: + if (Error == null) { + Error = new global::LiveKit.Proto.StreamError(); + } + Error.MergeFrom(other.Error); + break; + } + + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + AsyncId = input.ReadUInt64(); + break; + } + case 18: { + FilePath = input.ReadString(); + break; + } + case 26: { + global::LiveKit.Proto.StreamError subBuilder = new global::LiveKit.Proto.StreamError(); + if (resultCase_ == ResultOneofCase.Error) { + subBuilder.MergeFrom(Error); + } + input.ReadMessage(subBuilder); + Error = subBuilder; + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + AsyncId = input.ReadUInt64(); + break; + } + case 18: { + FilePath = input.ReadString(); + break; + } + case 26: { + global::LiveKit.Proto.StreamError subBuilder = new global::LiveKit.Proto.StreamError(); + if (resultCase_ == ResultOneofCase.Error) { + subBuilder.MergeFrom(Error); + } + input.ReadMessage(subBuilder); + Error = subBuilder; + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class ByteStreamReaderEvent : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ByteStreamReaderEvent()); + private pb::UnknownFieldSet _unknownFields; + private int _hasBits0; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.DataStreamReflection.Descriptor.MessageTypes[18]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ByteStreamReaderEvent() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ByteStreamReaderEvent(ByteStreamReaderEvent other) : this() { + _hasBits0 = other._hasBits0; + readerHandle_ = other.readerHandle_; + switch (other.DetailCase) { + case DetailOneofCase.ChunkReceived: + ChunkReceived = other.ChunkReceived.Clone(); + break; + case DetailOneofCase.Eos: + Eos = other.Eos.Clone(); + break; + } + + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ByteStreamReaderEvent Clone() { + return new ByteStreamReaderEvent(this); + } + + /// Field number for the "reader_handle" field. + public const int ReaderHandleFieldNumber = 1; + private readonly static ulong ReaderHandleDefaultValue = 0UL; + + private ulong readerHandle_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ulong ReaderHandle { + get { if ((_hasBits0 & 1) != 0) { return readerHandle_; } else { return ReaderHandleDefaultValue; } } + set { + _hasBits0 |= 1; + readerHandle_ = value; + } + } + /// Gets whether the "reader_handle" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasReaderHandle { + get { return (_hasBits0 & 1) != 0; } + } + /// Clears the value of the "reader_handle" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearReaderHandle() { + _hasBits0 &= ~1; + } + + /// Field number for the "chunk_received" field. + public const int ChunkReceivedFieldNumber = 2; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.ByteStreamReaderChunkReceived ChunkReceived { + get { return detailCase_ == DetailOneofCase.ChunkReceived ? (global::LiveKit.Proto.ByteStreamReaderChunkReceived) detail_ : null; } + set { + detail_ = value; + detailCase_ = value == null ? DetailOneofCase.None : DetailOneofCase.ChunkReceived; + } + } + + /// Field number for the "eos" field. + public const int EosFieldNumber = 3; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.ByteStreamReaderEOS Eos { + get { return detailCase_ == DetailOneofCase.Eos ? (global::LiveKit.Proto.ByteStreamReaderEOS) detail_ : null; } + set { + detail_ = value; + detailCase_ = value == null ? DetailOneofCase.None : DetailOneofCase.Eos; + } + } + + private object detail_; + /// Enum of possible cases for the "detail" oneof. + public enum DetailOneofCase { + None = 0, + ChunkReceived = 2, + Eos = 3, + } + private DetailOneofCase detailCase_ = DetailOneofCase.None; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public DetailOneofCase DetailCase { + get { return detailCase_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearDetail() { + detailCase_ = DetailOneofCase.None; + detail_ = null; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as ByteStreamReaderEvent); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(ByteStreamReaderEvent other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (ReaderHandle != other.ReaderHandle) return false; + if (!object.Equals(ChunkReceived, other.ChunkReceived)) return false; + if (!object.Equals(Eos, other.Eos)) return false; + if (DetailCase != other.DetailCase) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (HasReaderHandle) hash ^= ReaderHandle.GetHashCode(); + if (detailCase_ == DetailOneofCase.ChunkReceived) hash ^= ChunkReceived.GetHashCode(); + if (detailCase_ == DetailOneofCase.Eos) hash ^= Eos.GetHashCode(); + hash ^= (int) detailCase_; + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (HasReaderHandle) { + output.WriteRawTag(8); + output.WriteUInt64(ReaderHandle); + } + if (detailCase_ == DetailOneofCase.ChunkReceived) { + output.WriteRawTag(18); + output.WriteMessage(ChunkReceived); + } + if (detailCase_ == DetailOneofCase.Eos) { + output.WriteRawTag(26); + output.WriteMessage(Eos); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (HasReaderHandle) { + output.WriteRawTag(8); + output.WriteUInt64(ReaderHandle); + } + if (detailCase_ == DetailOneofCase.ChunkReceived) { + output.WriteRawTag(18); + output.WriteMessage(ChunkReceived); + } + if (detailCase_ == DetailOneofCase.Eos) { + output.WriteRawTag(26); + output.WriteMessage(Eos); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (HasReaderHandle) { + size += 1 + pb::CodedOutputStream.ComputeUInt64Size(ReaderHandle); + } + if (detailCase_ == DetailOneofCase.ChunkReceived) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(ChunkReceived); + } + if (detailCase_ == DetailOneofCase.Eos) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Eos); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(ByteStreamReaderEvent other) { + if (other == null) { + return; + } + if (other.HasReaderHandle) { + ReaderHandle = other.ReaderHandle; + } + switch (other.DetailCase) { + case DetailOneofCase.ChunkReceived: + if (ChunkReceived == null) { + ChunkReceived = new global::LiveKit.Proto.ByteStreamReaderChunkReceived(); + } + ChunkReceived.MergeFrom(other.ChunkReceived); + break; + case DetailOneofCase.Eos: + if (Eos == null) { + Eos = new global::LiveKit.Proto.ByteStreamReaderEOS(); + } + Eos.MergeFrom(other.Eos); + break; + } + + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + ReaderHandle = input.ReadUInt64(); + break; + } + case 18: { + global::LiveKit.Proto.ByteStreamReaderChunkReceived subBuilder = new global::LiveKit.Proto.ByteStreamReaderChunkReceived(); + if (detailCase_ == DetailOneofCase.ChunkReceived) { + subBuilder.MergeFrom(ChunkReceived); + } + input.ReadMessage(subBuilder); + ChunkReceived = subBuilder; + break; + } + case 26: { + global::LiveKit.Proto.ByteStreamReaderEOS subBuilder = new global::LiveKit.Proto.ByteStreamReaderEOS(); + if (detailCase_ == DetailOneofCase.Eos) { + subBuilder.MergeFrom(Eos); + } + input.ReadMessage(subBuilder); + Eos = subBuilder; + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + ReaderHandle = input.ReadUInt64(); + break; + } + case 18: { + global::LiveKit.Proto.ByteStreamReaderChunkReceived subBuilder = new global::LiveKit.Proto.ByteStreamReaderChunkReceived(); + if (detailCase_ == DetailOneofCase.ChunkReceived) { + subBuilder.MergeFrom(ChunkReceived); + } + input.ReadMessage(subBuilder); + ChunkReceived = subBuilder; + break; + } + case 26: { + global::LiveKit.Proto.ByteStreamReaderEOS subBuilder = new global::LiveKit.Proto.ByteStreamReaderEOS(); + if (detailCase_ == DetailOneofCase.Eos) { + subBuilder.MergeFrom(Eos); + } + input.ReadMessage(subBuilder); + Eos = subBuilder; + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class ByteStreamReaderChunkReceived : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ByteStreamReaderChunkReceived()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.DataStreamReflection.Descriptor.MessageTypes[19]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ByteStreamReaderChunkReceived() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ByteStreamReaderChunkReceived(ByteStreamReaderChunkReceived other) : this() { + content_ = other.content_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ByteStreamReaderChunkReceived Clone() { + return new ByteStreamReaderChunkReceived(this); + } + + /// Field number for the "content" field. + public const int ContentFieldNumber = 1; + private readonly static pb::ByteString ContentDefaultValue = pb::ByteString.Empty; + + private pb::ByteString content_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pb::ByteString Content { + get { return content_ ?? ContentDefaultValue; } + set { + content_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + /// Gets whether the "content" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasContent { + get { return content_ != null; } + } + /// Clears the value of the "content" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearContent() { + content_ = null; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as ByteStreamReaderChunkReceived); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(ByteStreamReaderChunkReceived other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Content != other.Content) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (HasContent) hash ^= Content.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (HasContent) { + output.WriteRawTag(10); + output.WriteBytes(Content); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (HasContent) { + output.WriteRawTag(10); + output.WriteBytes(Content); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (HasContent) { + size += 1 + pb::CodedOutputStream.ComputeBytesSize(Content); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(ByteStreamReaderChunkReceived other) { + if (other == null) { + return; + } + if (other.HasContent) { + Content = other.Content; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + Content = input.ReadBytes(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + Content = input.ReadBytes(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class ByteStreamReaderEOS : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ByteStreamReaderEOS()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.DataStreamReflection.Descriptor.MessageTypes[20]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ByteStreamReaderEOS() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ByteStreamReaderEOS(ByteStreamReaderEOS other) : this() { + error_ = other.error_ != null ? other.error_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ByteStreamReaderEOS Clone() { + return new ByteStreamReaderEOS(this); + } + + /// Field number for the "error" field. + public const int ErrorFieldNumber = 1; + private global::LiveKit.Proto.StreamError error_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.StreamError Error { + get { return error_; } + set { + error_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as ByteStreamReaderEOS); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(ByteStreamReaderEOS other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (!object.Equals(Error, other.Error)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (error_ != null) hash ^= Error.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (error_ != null) { + output.WriteRawTag(10); + output.WriteMessage(Error); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (error_ != null) { + output.WriteRawTag(10); + output.WriteMessage(Error); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (error_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Error); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(ByteStreamReaderEOS other) { + if (other == null) { + return; + } + if (other.error_ != null) { + if (error_ == null) { + Error = new global::LiveKit.Proto.StreamError(); + } + Error.MergeFrom(other.Error); + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + if (error_ == null) { + Error = new global::LiveKit.Proto.StreamError(); + } + input.ReadMessage(Error); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + if (error_ == null) { + Error = new global::LiveKit.Proto.StreamError(); + } + input.ReadMessage(Error); + break; + } + } + } + } + #endif + + } + + /// + /// Sends the contents of a file over a data stream. + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class StreamSendFileRequest : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new StreamSendFileRequest()); + private pb::UnknownFieldSet _unknownFields; + private int _hasBits0; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.DataStreamReflection.Descriptor.MessageTypes[21]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public StreamSendFileRequest() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public StreamSendFileRequest(StreamSendFileRequest other) : this() { + _hasBits0 = other._hasBits0; + localParticipantHandle_ = other.localParticipantHandle_; + options_ = other.options_ != null ? other.options_.Clone() : null; + filePath_ = other.filePath_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public StreamSendFileRequest Clone() { + return new StreamSendFileRequest(this); + } + + /// Field number for the "local_participant_handle" field. + public const int LocalParticipantHandleFieldNumber = 1; + private readonly static ulong LocalParticipantHandleDefaultValue = 0UL; + + private ulong localParticipantHandle_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ulong LocalParticipantHandle { + get { if ((_hasBits0 & 1) != 0) { return localParticipantHandle_; } else { return LocalParticipantHandleDefaultValue; } } + set { + _hasBits0 |= 1; + localParticipantHandle_ = value; + } + } + /// Gets whether the "local_participant_handle" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasLocalParticipantHandle { + get { return (_hasBits0 & 1) != 0; } + } + /// Clears the value of the "local_participant_handle" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearLocalParticipantHandle() { + _hasBits0 &= ~1; + } + + /// Field number for the "options" field. + public const int OptionsFieldNumber = 2; + private global::LiveKit.Proto.StreamByteOptions options_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.StreamByteOptions Options { + get { return options_; } + set { + options_ = value; + } + } + + /// Field number for the "file_path" field. + public const int FilePathFieldNumber = 3; + private readonly static string FilePathDefaultValue = ""; + + private string filePath_; + /// + /// Path of the file to send (must be readable by the current process). + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string FilePath { + get { return filePath_ ?? FilePathDefaultValue; } + set { + filePath_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + /// Gets whether the "file_path" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasFilePath { + get { return filePath_ != null; } + } + /// Clears the value of the "file_path" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearFilePath() { + filePath_ = null; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as StreamSendFileRequest); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(StreamSendFileRequest other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (LocalParticipantHandle != other.LocalParticipantHandle) return false; + if (!object.Equals(Options, other.Options)) return false; + if (FilePath != other.FilePath) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (HasLocalParticipantHandle) hash ^= LocalParticipantHandle.GetHashCode(); + if (options_ != null) hash ^= Options.GetHashCode(); + if (HasFilePath) hash ^= FilePath.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (HasLocalParticipantHandle) { + output.WriteRawTag(8); + output.WriteUInt64(LocalParticipantHandle); + } + if (options_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Options); + } + if (HasFilePath) { + output.WriteRawTag(26); + output.WriteString(FilePath); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (HasLocalParticipantHandle) { + output.WriteRawTag(8); + output.WriteUInt64(LocalParticipantHandle); + } + if (options_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Options); + } + if (HasFilePath) { + output.WriteRawTag(26); + output.WriteString(FilePath); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (HasLocalParticipantHandle) { + size += 1 + pb::CodedOutputStream.ComputeUInt64Size(LocalParticipantHandle); + } + if (options_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Options); + } + if (HasFilePath) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(FilePath); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(StreamSendFileRequest other) { + if (other == null) { + return; + } + if (other.HasLocalParticipantHandle) { + LocalParticipantHandle = other.LocalParticipantHandle; + } + if (other.options_ != null) { + if (options_ == null) { + Options = new global::LiveKit.Proto.StreamByteOptions(); + } + Options.MergeFrom(other.Options); + } + if (other.HasFilePath) { + FilePath = other.FilePath; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + LocalParticipantHandle = input.ReadUInt64(); + break; + } + case 18: { + if (options_ == null) { + Options = new global::LiveKit.Proto.StreamByteOptions(); + } + input.ReadMessage(Options); + break; + } + case 26: { + FilePath = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + LocalParticipantHandle = input.ReadUInt64(); + break; + } + case 18: { + if (options_ == null) { + Options = new global::LiveKit.Proto.StreamByteOptions(); + } + input.ReadMessage(Options); + break; + } + case 26: { + FilePath = input.ReadString(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class StreamSendFileResponse : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new StreamSendFileResponse()); + private pb::UnknownFieldSet _unknownFields; + private int _hasBits0; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.DataStreamReflection.Descriptor.MessageTypes[22]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public StreamSendFileResponse() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public StreamSendFileResponse(StreamSendFileResponse other) : this() { + _hasBits0 = other._hasBits0; + asyncId_ = other.asyncId_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public StreamSendFileResponse Clone() { + return new StreamSendFileResponse(this); + } + + /// Field number for the "async_id" field. + public const int AsyncIdFieldNumber = 1; + private readonly static ulong AsyncIdDefaultValue = 0UL; + + private ulong asyncId_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ulong AsyncId { + get { if ((_hasBits0 & 1) != 0) { return asyncId_; } else { return AsyncIdDefaultValue; } } + set { + _hasBits0 |= 1; + asyncId_ = value; + } + } + /// Gets whether the "async_id" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasAsyncId { + get { return (_hasBits0 & 1) != 0; } + } + /// Clears the value of the "async_id" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearAsyncId() { + _hasBits0 &= ~1; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as StreamSendFileResponse); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(StreamSendFileResponse other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (AsyncId != other.AsyncId) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (HasAsyncId) hash ^= AsyncId.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (HasAsyncId) { + output.WriteRawTag(8); + output.WriteUInt64(AsyncId); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (HasAsyncId) { + output.WriteRawTag(8); + output.WriteUInt64(AsyncId); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (HasAsyncId) { + size += 1 + pb::CodedOutputStream.ComputeUInt64Size(AsyncId); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(StreamSendFileResponse other) { + if (other == null) { + return; + } + if (other.HasAsyncId) { + AsyncId = other.AsyncId; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + AsyncId = input.ReadUInt64(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + AsyncId = input.ReadUInt64(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class StreamSendFileCallback : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new StreamSendFileCallback()); + private pb::UnknownFieldSet _unknownFields; + private int _hasBits0; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.DataStreamReflection.Descriptor.MessageTypes[23]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public StreamSendFileCallback() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public StreamSendFileCallback(StreamSendFileCallback other) : this() { + _hasBits0 = other._hasBits0; + asyncId_ = other.asyncId_; + switch (other.ResultCase) { + case ResultOneofCase.Info: + Info = other.Info.Clone(); + break; + case ResultOneofCase.Error: + Error = other.Error.Clone(); + break; + } + + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public StreamSendFileCallback Clone() { + return new StreamSendFileCallback(this); + } + + /// Field number for the "async_id" field. + public const int AsyncIdFieldNumber = 1; + private readonly static ulong AsyncIdDefaultValue = 0UL; + + private ulong asyncId_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ulong AsyncId { + get { if ((_hasBits0 & 1) != 0) { return asyncId_; } else { return AsyncIdDefaultValue; } } + set { + _hasBits0 |= 1; + asyncId_ = value; + } + } + /// Gets whether the "async_id" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasAsyncId { + get { return (_hasBits0 & 1) != 0; } + } + /// Clears the value of the "async_id" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearAsyncId() { + _hasBits0 &= ~1; + } + + /// Field number for the "info" field. + public const int InfoFieldNumber = 2; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.ByteStreamInfo Info { + get { return resultCase_ == ResultOneofCase.Info ? (global::LiveKit.Proto.ByteStreamInfo) result_ : null; } + set { + result_ = value; + resultCase_ = value == null ? ResultOneofCase.None : ResultOneofCase.Info; + } + } + + /// Field number for the "error" field. + public const int ErrorFieldNumber = 3; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.StreamError Error { + get { return resultCase_ == ResultOneofCase.Error ? (global::LiveKit.Proto.StreamError) result_ : null; } + set { + result_ = value; + resultCase_ = value == null ? ResultOneofCase.None : ResultOneofCase.Error; + } + } + + private object result_; + /// Enum of possible cases for the "result" oneof. + public enum ResultOneofCase { + None = 0, + Info = 2, + Error = 3, + } + private ResultOneofCase resultCase_ = ResultOneofCase.None; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ResultOneofCase ResultCase { + get { return resultCase_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearResult() { + resultCase_ = ResultOneofCase.None; + result_ = null; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as StreamSendFileCallback); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(StreamSendFileCallback other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (AsyncId != other.AsyncId) return false; + if (!object.Equals(Info, other.Info)) return false; + if (!object.Equals(Error, other.Error)) return false; + if (ResultCase != other.ResultCase) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (HasAsyncId) hash ^= AsyncId.GetHashCode(); + if (resultCase_ == ResultOneofCase.Info) hash ^= Info.GetHashCode(); + if (resultCase_ == ResultOneofCase.Error) hash ^= Error.GetHashCode(); + hash ^= (int) resultCase_; + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (HasAsyncId) { + output.WriteRawTag(8); + output.WriteUInt64(AsyncId); + } + if (resultCase_ == ResultOneofCase.Info) { + output.WriteRawTag(18); + output.WriteMessage(Info); + } + if (resultCase_ == ResultOneofCase.Error) { + output.WriteRawTag(26); + output.WriteMessage(Error); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (HasAsyncId) { + output.WriteRawTag(8); + output.WriteUInt64(AsyncId); + } + if (resultCase_ == ResultOneofCase.Info) { + output.WriteRawTag(18); + output.WriteMessage(Info); + } + if (resultCase_ == ResultOneofCase.Error) { + output.WriteRawTag(26); + output.WriteMessage(Error); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (HasAsyncId) { + size += 1 + pb::CodedOutputStream.ComputeUInt64Size(AsyncId); + } + if (resultCase_ == ResultOneofCase.Info) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Info); + } + if (resultCase_ == ResultOneofCase.Error) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Error); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(StreamSendFileCallback other) { + if (other == null) { + return; + } + if (other.HasAsyncId) { + AsyncId = other.AsyncId; + } + switch (other.ResultCase) { + case ResultOneofCase.Info: + if (Info == null) { + Info = new global::LiveKit.Proto.ByteStreamInfo(); + } + Info.MergeFrom(other.Info); + break; + case ResultOneofCase.Error: + if (Error == null) { + Error = new global::LiveKit.Proto.StreamError(); + } + Error.MergeFrom(other.Error); + break; + } + + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + AsyncId = input.ReadUInt64(); + break; + } + case 18: { + global::LiveKit.Proto.ByteStreamInfo subBuilder = new global::LiveKit.Proto.ByteStreamInfo(); + if (resultCase_ == ResultOneofCase.Info) { + subBuilder.MergeFrom(Info); + } + input.ReadMessage(subBuilder); + Info = subBuilder; + break; + } + case 26: { + global::LiveKit.Proto.StreamError subBuilder = new global::LiveKit.Proto.StreamError(); + if (resultCase_ == ResultOneofCase.Error) { + subBuilder.MergeFrom(Error); + } + input.ReadMessage(subBuilder); + Error = subBuilder; + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + AsyncId = input.ReadUInt64(); + break; + } + case 18: { + global::LiveKit.Proto.ByteStreamInfo subBuilder = new global::LiveKit.Proto.ByteStreamInfo(); + if (resultCase_ == ResultOneofCase.Info) { + subBuilder.MergeFrom(Info); + } + input.ReadMessage(subBuilder); + Info = subBuilder; + break; + } + case 26: { + global::LiveKit.Proto.StreamError subBuilder = new global::LiveKit.Proto.StreamError(); + if (resultCase_ == ResultOneofCase.Error) { + subBuilder.MergeFrom(Error); + } + input.ReadMessage(subBuilder); + Error = subBuilder; + break; + } + } + } + } + #endif + + } + + /// + /// Sends text over a data stream. + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class StreamSendTextRequest : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new StreamSendTextRequest()); + private pb::UnknownFieldSet _unknownFields; + private int _hasBits0; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.DataStreamReflection.Descriptor.MessageTypes[24]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public StreamSendTextRequest() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public StreamSendTextRequest(StreamSendTextRequest other) : this() { + _hasBits0 = other._hasBits0; + localParticipantHandle_ = other.localParticipantHandle_; + options_ = other.options_ != null ? other.options_.Clone() : null; + text_ = other.text_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public StreamSendTextRequest Clone() { + return new StreamSendTextRequest(this); + } + + /// Field number for the "local_participant_handle" field. + public const int LocalParticipantHandleFieldNumber = 1; + private readonly static ulong LocalParticipantHandleDefaultValue = 0UL; + + private ulong localParticipantHandle_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ulong LocalParticipantHandle { + get { if ((_hasBits0 & 1) != 0) { return localParticipantHandle_; } else { return LocalParticipantHandleDefaultValue; } } + set { + _hasBits0 |= 1; + localParticipantHandle_ = value; + } + } + /// Gets whether the "local_participant_handle" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasLocalParticipantHandle { + get { return (_hasBits0 & 1) != 0; } + } + /// Clears the value of the "local_participant_handle" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearLocalParticipantHandle() { + _hasBits0 &= ~1; + } + + /// Field number for the "options" field. + public const int OptionsFieldNumber = 2; + private global::LiveKit.Proto.StreamTextOptions options_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.StreamTextOptions Options { + get { return options_; } + set { + options_ = value; + } + } + + /// Field number for the "text" field. + public const int TextFieldNumber = 3; + private readonly static string TextDefaultValue = ""; + + private string text_; + /// + /// Text to send. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Text { + get { return text_ ?? TextDefaultValue; } + set { + text_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + /// Gets whether the "text" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasText { + get { return text_ != null; } + } + /// Clears the value of the "text" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearText() { + text_ = null; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as StreamSendTextRequest); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(StreamSendTextRequest other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (LocalParticipantHandle != other.LocalParticipantHandle) return false; + if (!object.Equals(Options, other.Options)) return false; + if (Text != other.Text) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (HasLocalParticipantHandle) hash ^= LocalParticipantHandle.GetHashCode(); + if (options_ != null) hash ^= Options.GetHashCode(); + if (HasText) hash ^= Text.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (HasLocalParticipantHandle) { + output.WriteRawTag(8); + output.WriteUInt64(LocalParticipantHandle); + } + if (options_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Options); + } + if (HasText) { + output.WriteRawTag(26); + output.WriteString(Text); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (HasLocalParticipantHandle) { + output.WriteRawTag(8); + output.WriteUInt64(LocalParticipantHandle); + } + if (options_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Options); + } + if (HasText) { + output.WriteRawTag(26); + output.WriteString(Text); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (HasLocalParticipantHandle) { + size += 1 + pb::CodedOutputStream.ComputeUInt64Size(LocalParticipantHandle); + } + if (options_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Options); + } + if (HasText) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Text); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(StreamSendTextRequest other) { + if (other == null) { + return; + } + if (other.HasLocalParticipantHandle) { + LocalParticipantHandle = other.LocalParticipantHandle; + } + if (other.options_ != null) { + if (options_ == null) { + Options = new global::LiveKit.Proto.StreamTextOptions(); + } + Options.MergeFrom(other.Options); + } + if (other.HasText) { + Text = other.Text; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + LocalParticipantHandle = input.ReadUInt64(); + break; + } + case 18: { + if (options_ == null) { + Options = new global::LiveKit.Proto.StreamTextOptions(); + } + input.ReadMessage(Options); + break; + } + case 26: { + Text = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + LocalParticipantHandle = input.ReadUInt64(); + break; + } + case 18: { + if (options_ == null) { + Options = new global::LiveKit.Proto.StreamTextOptions(); + } + input.ReadMessage(Options); + break; + } + case 26: { + Text = input.ReadString(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class StreamSendTextResponse : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new StreamSendTextResponse()); + private pb::UnknownFieldSet _unknownFields; + private int _hasBits0; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.DataStreamReflection.Descriptor.MessageTypes[25]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public StreamSendTextResponse() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public StreamSendTextResponse(StreamSendTextResponse other) : this() { + _hasBits0 = other._hasBits0; + asyncId_ = other.asyncId_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public StreamSendTextResponse Clone() { + return new StreamSendTextResponse(this); + } + + /// Field number for the "async_id" field. + public const int AsyncIdFieldNumber = 1; + private readonly static ulong AsyncIdDefaultValue = 0UL; + + private ulong asyncId_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ulong AsyncId { + get { if ((_hasBits0 & 1) != 0) { return asyncId_; } else { return AsyncIdDefaultValue; } } + set { + _hasBits0 |= 1; + asyncId_ = value; + } + } + /// Gets whether the "async_id" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasAsyncId { + get { return (_hasBits0 & 1) != 0; } + } + /// Clears the value of the "async_id" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearAsyncId() { + _hasBits0 &= ~1; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as StreamSendTextResponse); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(StreamSendTextResponse other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (AsyncId != other.AsyncId) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (HasAsyncId) hash ^= AsyncId.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (HasAsyncId) { + output.WriteRawTag(8); + output.WriteUInt64(AsyncId); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (HasAsyncId) { + output.WriteRawTag(8); + output.WriteUInt64(AsyncId); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (HasAsyncId) { + size += 1 + pb::CodedOutputStream.ComputeUInt64Size(AsyncId); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(StreamSendTextResponse other) { + if (other == null) { + return; + } + if (other.HasAsyncId) { + AsyncId = other.AsyncId; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + AsyncId = input.ReadUInt64(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + AsyncId = input.ReadUInt64(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class StreamSendTextCallback : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new StreamSendTextCallback()); + private pb::UnknownFieldSet _unknownFields; + private int _hasBits0; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.DataStreamReflection.Descriptor.MessageTypes[26]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public StreamSendTextCallback() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public StreamSendTextCallback(StreamSendTextCallback other) : this() { + _hasBits0 = other._hasBits0; + asyncId_ = other.asyncId_; + switch (other.ResultCase) { + case ResultOneofCase.Info: + Info = other.Info.Clone(); + break; + case ResultOneofCase.Error: + Error = other.Error.Clone(); + break; + } + + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public StreamSendTextCallback Clone() { + return new StreamSendTextCallback(this); + } + + /// Field number for the "async_id" field. + public const int AsyncIdFieldNumber = 1; + private readonly static ulong AsyncIdDefaultValue = 0UL; + + private ulong asyncId_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ulong AsyncId { + get { if ((_hasBits0 & 1) != 0) { return asyncId_; } else { return AsyncIdDefaultValue; } } + set { + _hasBits0 |= 1; + asyncId_ = value; + } + } + /// Gets whether the "async_id" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasAsyncId { + get { return (_hasBits0 & 1) != 0; } + } + /// Clears the value of the "async_id" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearAsyncId() { + _hasBits0 &= ~1; + } + + /// Field number for the "info" field. + public const int InfoFieldNumber = 2; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.TextStreamInfo Info { + get { return resultCase_ == ResultOneofCase.Info ? (global::LiveKit.Proto.TextStreamInfo) result_ : null; } + set { + result_ = value; + resultCase_ = value == null ? ResultOneofCase.None : ResultOneofCase.Info; + } + } + + /// Field number for the "error" field. + public const int ErrorFieldNumber = 3; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.StreamError Error { + get { return resultCase_ == ResultOneofCase.Error ? (global::LiveKit.Proto.StreamError) result_ : null; } + set { + result_ = value; + resultCase_ = value == null ? ResultOneofCase.None : ResultOneofCase.Error; + } + } + + private object result_; + /// Enum of possible cases for the "result" oneof. + public enum ResultOneofCase { + None = 0, + Info = 2, + Error = 3, + } + private ResultOneofCase resultCase_ = ResultOneofCase.None; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ResultOneofCase ResultCase { + get { return resultCase_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearResult() { + resultCase_ = ResultOneofCase.None; + result_ = null; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as StreamSendTextCallback); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(StreamSendTextCallback other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (AsyncId != other.AsyncId) return false; + if (!object.Equals(Info, other.Info)) return false; + if (!object.Equals(Error, other.Error)) return false; + if (ResultCase != other.ResultCase) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (HasAsyncId) hash ^= AsyncId.GetHashCode(); + if (resultCase_ == ResultOneofCase.Info) hash ^= Info.GetHashCode(); + if (resultCase_ == ResultOneofCase.Error) hash ^= Error.GetHashCode(); + hash ^= (int) resultCase_; + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (HasAsyncId) { + output.WriteRawTag(8); + output.WriteUInt64(AsyncId); + } + if (resultCase_ == ResultOneofCase.Info) { + output.WriteRawTag(18); + output.WriteMessage(Info); + } + if (resultCase_ == ResultOneofCase.Error) { + output.WriteRawTag(26); + output.WriteMessage(Error); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (HasAsyncId) { + output.WriteRawTag(8); + output.WriteUInt64(AsyncId); + } + if (resultCase_ == ResultOneofCase.Info) { + output.WriteRawTag(18); + output.WriteMessage(Info); + } + if (resultCase_ == ResultOneofCase.Error) { + output.WriteRawTag(26); + output.WriteMessage(Error); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (HasAsyncId) { + size += 1 + pb::CodedOutputStream.ComputeUInt64Size(AsyncId); + } + if (resultCase_ == ResultOneofCase.Info) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Info); + } + if (resultCase_ == ResultOneofCase.Error) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Error); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(StreamSendTextCallback other) { + if (other == null) { + return; + } + if (other.HasAsyncId) { + AsyncId = other.AsyncId; + } + switch (other.ResultCase) { + case ResultOneofCase.Info: + if (Info == null) { + Info = new global::LiveKit.Proto.TextStreamInfo(); + } + Info.MergeFrom(other.Info); + break; + case ResultOneofCase.Error: + if (Error == null) { + Error = new global::LiveKit.Proto.StreamError(); + } + Error.MergeFrom(other.Error); + break; + } + + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + AsyncId = input.ReadUInt64(); + break; + } + case 18: { + global::LiveKit.Proto.TextStreamInfo subBuilder = new global::LiveKit.Proto.TextStreamInfo(); + if (resultCase_ == ResultOneofCase.Info) { + subBuilder.MergeFrom(Info); + } + input.ReadMessage(subBuilder); + Info = subBuilder; + break; + } + case 26: { + global::LiveKit.Proto.StreamError subBuilder = new global::LiveKit.Proto.StreamError(); + if (resultCase_ == ResultOneofCase.Error) { + subBuilder.MergeFrom(Error); + } + input.ReadMessage(subBuilder); + Error = subBuilder; + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + AsyncId = input.ReadUInt64(); + break; + } + case 18: { + global::LiveKit.Proto.TextStreamInfo subBuilder = new global::LiveKit.Proto.TextStreamInfo(); + if (resultCase_ == ResultOneofCase.Info) { + subBuilder.MergeFrom(Info); + } + input.ReadMessage(subBuilder); + Info = subBuilder; + break; + } + case 26: { + global::LiveKit.Proto.StreamError subBuilder = new global::LiveKit.Proto.StreamError(); + if (resultCase_ == ResultOneofCase.Error) { + subBuilder.MergeFrom(Error); + } + input.ReadMessage(subBuilder); + Error = subBuilder; + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class OwnedByteStreamWriter : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new OwnedByteStreamWriter()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.DataStreamReflection.Descriptor.MessageTypes[27]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public OwnedByteStreamWriter() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public OwnedByteStreamWriter(OwnedByteStreamWriter other) : this() { + handle_ = other.handle_ != null ? other.handle_.Clone() : null; + info_ = other.info_ != null ? other.info_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public OwnedByteStreamWriter Clone() { + return new OwnedByteStreamWriter(this); + } + + /// Field number for the "handle" field. + public const int HandleFieldNumber = 1; + private global::LiveKit.Proto.FfiOwnedHandle handle_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.FfiOwnedHandle Handle { + get { return handle_; } + set { + handle_ = value; + } + } + + /// Field number for the "info" field. + public const int InfoFieldNumber = 2; + private global::LiveKit.Proto.ByteStreamInfo info_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.ByteStreamInfo Info { + get { return info_; } + set { + info_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as OwnedByteStreamWriter); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(OwnedByteStreamWriter other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (!object.Equals(Handle, other.Handle)) return false; + if (!object.Equals(Info, other.Info)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (handle_ != null) hash ^= Handle.GetHashCode(); + if (info_ != null) hash ^= Info.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (handle_ != null) { + output.WriteRawTag(10); + output.WriteMessage(Handle); + } + if (info_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Info); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (handle_ != null) { + output.WriteRawTag(10); + output.WriteMessage(Handle); + } + if (info_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Info); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (handle_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Handle); + } + if (info_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Info); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(OwnedByteStreamWriter other) { + if (other == null) { + return; + } + if (other.handle_ != null) { + if (handle_ == null) { + Handle = new global::LiveKit.Proto.FfiOwnedHandle(); + } + Handle.MergeFrom(other.Handle); + } + if (other.info_ != null) { + if (info_ == null) { + Info = new global::LiveKit.Proto.ByteStreamInfo(); + } + Info.MergeFrom(other.Info); + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + if (handle_ == null) { + Handle = new global::LiveKit.Proto.FfiOwnedHandle(); + } + input.ReadMessage(Handle); + break; + } + case 18: { + if (info_ == null) { + Info = new global::LiveKit.Proto.ByteStreamInfo(); + } + input.ReadMessage(Info); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + if (handle_ == null) { + Handle = new global::LiveKit.Proto.FfiOwnedHandle(); + } + input.ReadMessage(Handle); + break; + } + case 18: { + if (info_ == null) { + Info = new global::LiveKit.Proto.ByteStreamInfo(); + } + input.ReadMessage(Info); + break; + } + } + } + } + #endif + + } + + /// + /// Opens an outgoing stream. + /// Call must be balanced with a StreamCloseRequest. + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class ByteStreamOpenRequest : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ByteStreamOpenRequest()); + private pb::UnknownFieldSet _unknownFields; + private int _hasBits0; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.DataStreamReflection.Descriptor.MessageTypes[28]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ByteStreamOpenRequest() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ByteStreamOpenRequest(ByteStreamOpenRequest other) : this() { + _hasBits0 = other._hasBits0; + localParticipantHandle_ = other.localParticipantHandle_; + options_ = other.options_ != null ? other.options_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ByteStreamOpenRequest Clone() { + return new ByteStreamOpenRequest(this); + } + + /// Field number for the "local_participant_handle" field. + public const int LocalParticipantHandleFieldNumber = 1; + private readonly static ulong LocalParticipantHandleDefaultValue = 0UL; + + private ulong localParticipantHandle_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ulong LocalParticipantHandle { + get { if ((_hasBits0 & 1) != 0) { return localParticipantHandle_; } else { return LocalParticipantHandleDefaultValue; } } + set { + _hasBits0 |= 1; + localParticipantHandle_ = value; + } + } + /// Gets whether the "local_participant_handle" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasLocalParticipantHandle { + get { return (_hasBits0 & 1) != 0; } + } + /// Clears the value of the "local_participant_handle" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearLocalParticipantHandle() { + _hasBits0 &= ~1; + } + + /// Field number for the "options" field. + public const int OptionsFieldNumber = 2; + private global::LiveKit.Proto.StreamByteOptions options_; + /// + /// Options to use for opening the stream. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.StreamByteOptions Options { + get { return options_; } + set { + options_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as ByteStreamOpenRequest); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(ByteStreamOpenRequest other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (LocalParticipantHandle != other.LocalParticipantHandle) return false; + if (!object.Equals(Options, other.Options)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (HasLocalParticipantHandle) hash ^= LocalParticipantHandle.GetHashCode(); + if (options_ != null) hash ^= Options.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (HasLocalParticipantHandle) { + output.WriteRawTag(8); + output.WriteUInt64(LocalParticipantHandle); + } + if (options_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Options); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (HasLocalParticipantHandle) { + output.WriteRawTag(8); + output.WriteUInt64(LocalParticipantHandle); + } + if (options_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Options); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (HasLocalParticipantHandle) { + size += 1 + pb::CodedOutputStream.ComputeUInt64Size(LocalParticipantHandle); + } + if (options_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Options); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(ByteStreamOpenRequest other) { + if (other == null) { + return; + } + if (other.HasLocalParticipantHandle) { + LocalParticipantHandle = other.LocalParticipantHandle; + } + if (other.options_ != null) { + if (options_ == null) { + Options = new global::LiveKit.Proto.StreamByteOptions(); + } + Options.MergeFrom(other.Options); + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + LocalParticipantHandle = input.ReadUInt64(); + break; + } + case 18: { + if (options_ == null) { + Options = new global::LiveKit.Proto.StreamByteOptions(); + } + input.ReadMessage(Options); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + LocalParticipantHandle = input.ReadUInt64(); + break; + } + case 18: { + if (options_ == null) { + Options = new global::LiveKit.Proto.StreamByteOptions(); + } + input.ReadMessage(Options); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class ByteStreamOpenResponse : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ByteStreamOpenResponse()); + private pb::UnknownFieldSet _unknownFields; + private int _hasBits0; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.DataStreamReflection.Descriptor.MessageTypes[29]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ByteStreamOpenResponse() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ByteStreamOpenResponse(ByteStreamOpenResponse other) : this() { + _hasBits0 = other._hasBits0; + asyncId_ = other.asyncId_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ByteStreamOpenResponse Clone() { + return new ByteStreamOpenResponse(this); + } + + /// Field number for the "async_id" field. + public const int AsyncIdFieldNumber = 1; + private readonly static ulong AsyncIdDefaultValue = 0UL; + + private ulong asyncId_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ulong AsyncId { + get { if ((_hasBits0 & 1) != 0) { return asyncId_; } else { return AsyncIdDefaultValue; } } + set { + _hasBits0 |= 1; + asyncId_ = value; + } + } + /// Gets whether the "async_id" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasAsyncId { + get { return (_hasBits0 & 1) != 0; } + } + /// Clears the value of the "async_id" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearAsyncId() { + _hasBits0 &= ~1; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as ByteStreamOpenResponse); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(ByteStreamOpenResponse other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (AsyncId != other.AsyncId) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (HasAsyncId) hash ^= AsyncId.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (HasAsyncId) { + output.WriteRawTag(8); + output.WriteUInt64(AsyncId); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (HasAsyncId) { + output.WriteRawTag(8); + output.WriteUInt64(AsyncId); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (HasAsyncId) { + size += 1 + pb::CodedOutputStream.ComputeUInt64Size(AsyncId); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(ByteStreamOpenResponse other) { + if (other == null) { + return; + } + if (other.HasAsyncId) { + AsyncId = other.AsyncId; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + AsyncId = input.ReadUInt64(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + AsyncId = input.ReadUInt64(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class ByteStreamOpenCallback : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ByteStreamOpenCallback()); + private pb::UnknownFieldSet _unknownFields; + private int _hasBits0; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.DataStreamReflection.Descriptor.MessageTypes[30]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ByteStreamOpenCallback() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ByteStreamOpenCallback(ByteStreamOpenCallback other) : this() { + _hasBits0 = other._hasBits0; + asyncId_ = other.asyncId_; + switch (other.ResultCase) { + case ResultOneofCase.Writer: + Writer = other.Writer.Clone(); + break; + case ResultOneofCase.Error: + Error = other.Error.Clone(); + break; + } + + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ByteStreamOpenCallback Clone() { + return new ByteStreamOpenCallback(this); + } + + /// Field number for the "async_id" field. + public const int AsyncIdFieldNumber = 1; + private readonly static ulong AsyncIdDefaultValue = 0UL; + + private ulong asyncId_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ulong AsyncId { + get { if ((_hasBits0 & 1) != 0) { return asyncId_; } else { return AsyncIdDefaultValue; } } + set { + _hasBits0 |= 1; + asyncId_ = value; + } + } + /// Gets whether the "async_id" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasAsyncId { + get { return (_hasBits0 & 1) != 0; } + } + /// Clears the value of the "async_id" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearAsyncId() { + _hasBits0 &= ~1; + } + + /// Field number for the "writer" field. + public const int WriterFieldNumber = 2; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.OwnedByteStreamWriter Writer { + get { return resultCase_ == ResultOneofCase.Writer ? (global::LiveKit.Proto.OwnedByteStreamWriter) result_ : null; } + set { + result_ = value; + resultCase_ = value == null ? ResultOneofCase.None : ResultOneofCase.Writer; + } + } + + /// Field number for the "error" field. + public const int ErrorFieldNumber = 3; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.StreamError Error { + get { return resultCase_ == ResultOneofCase.Error ? (global::LiveKit.Proto.StreamError) result_ : null; } + set { + result_ = value; + resultCase_ = value == null ? ResultOneofCase.None : ResultOneofCase.Error; + } + } + + private object result_; + /// Enum of possible cases for the "result" oneof. + public enum ResultOneofCase { + None = 0, + Writer = 2, + Error = 3, + } + private ResultOneofCase resultCase_ = ResultOneofCase.None; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ResultOneofCase ResultCase { + get { return resultCase_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearResult() { + resultCase_ = ResultOneofCase.None; + result_ = null; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as ByteStreamOpenCallback); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(ByteStreamOpenCallback other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (AsyncId != other.AsyncId) return false; + if (!object.Equals(Writer, other.Writer)) return false; + if (!object.Equals(Error, other.Error)) return false; + if (ResultCase != other.ResultCase) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (HasAsyncId) hash ^= AsyncId.GetHashCode(); + if (resultCase_ == ResultOneofCase.Writer) hash ^= Writer.GetHashCode(); + if (resultCase_ == ResultOneofCase.Error) hash ^= Error.GetHashCode(); + hash ^= (int) resultCase_; + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (HasAsyncId) { + output.WriteRawTag(8); + output.WriteUInt64(AsyncId); + } + if (resultCase_ == ResultOneofCase.Writer) { + output.WriteRawTag(18); + output.WriteMessage(Writer); + } + if (resultCase_ == ResultOneofCase.Error) { + output.WriteRawTag(26); + output.WriteMessage(Error); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (HasAsyncId) { + output.WriteRawTag(8); + output.WriteUInt64(AsyncId); + } + if (resultCase_ == ResultOneofCase.Writer) { + output.WriteRawTag(18); + output.WriteMessage(Writer); + } + if (resultCase_ == ResultOneofCase.Error) { + output.WriteRawTag(26); + output.WriteMessage(Error); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (HasAsyncId) { + size += 1 + pb::CodedOutputStream.ComputeUInt64Size(AsyncId); + } + if (resultCase_ == ResultOneofCase.Writer) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Writer); + } + if (resultCase_ == ResultOneofCase.Error) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Error); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(ByteStreamOpenCallback other) { + if (other == null) { + return; + } + if (other.HasAsyncId) { + AsyncId = other.AsyncId; + } + switch (other.ResultCase) { + case ResultOneofCase.Writer: + if (Writer == null) { + Writer = new global::LiveKit.Proto.OwnedByteStreamWriter(); + } + Writer.MergeFrom(other.Writer); + break; + case ResultOneofCase.Error: + if (Error == null) { + Error = new global::LiveKit.Proto.StreamError(); + } + Error.MergeFrom(other.Error); + break; + } + + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + AsyncId = input.ReadUInt64(); + break; + } + case 18: { + global::LiveKit.Proto.OwnedByteStreamWriter subBuilder = new global::LiveKit.Proto.OwnedByteStreamWriter(); + if (resultCase_ == ResultOneofCase.Writer) { + subBuilder.MergeFrom(Writer); + } + input.ReadMessage(subBuilder); + Writer = subBuilder; + break; + } + case 26: { + global::LiveKit.Proto.StreamError subBuilder = new global::LiveKit.Proto.StreamError(); + if (resultCase_ == ResultOneofCase.Error) { + subBuilder.MergeFrom(Error); + } + input.ReadMessage(subBuilder); + Error = subBuilder; + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + AsyncId = input.ReadUInt64(); + break; + } + case 18: { + global::LiveKit.Proto.OwnedByteStreamWriter subBuilder = new global::LiveKit.Proto.OwnedByteStreamWriter(); + if (resultCase_ == ResultOneofCase.Writer) { + subBuilder.MergeFrom(Writer); + } + input.ReadMessage(subBuilder); + Writer = subBuilder; + break; + } + case 26: { + global::LiveKit.Proto.StreamError subBuilder = new global::LiveKit.Proto.StreamError(); + if (resultCase_ == ResultOneofCase.Error) { + subBuilder.MergeFrom(Error); + } + input.ReadMessage(subBuilder); + Error = subBuilder; + break; + } + } + } + } + #endif + + } + + /// + /// Writes data to a stream writer. + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class ByteStreamWriterWriteRequest : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ByteStreamWriterWriteRequest()); + private pb::UnknownFieldSet _unknownFields; + private int _hasBits0; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.DataStreamReflection.Descriptor.MessageTypes[31]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ByteStreamWriterWriteRequest() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ByteStreamWriterWriteRequest(ByteStreamWriterWriteRequest other) : this() { + _hasBits0 = other._hasBits0; + writerHandle_ = other.writerHandle_; + bytes_ = other.bytes_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ByteStreamWriterWriteRequest Clone() { + return new ByteStreamWriterWriteRequest(this); + } + + /// Field number for the "writer_handle" field. + public const int WriterHandleFieldNumber = 1; + private readonly static ulong WriterHandleDefaultValue = 0UL; + + private ulong writerHandle_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ulong WriterHandle { + get { if ((_hasBits0 & 1) != 0) { return writerHandle_; } else { return WriterHandleDefaultValue; } } + set { + _hasBits0 |= 1; + writerHandle_ = value; + } + } + /// Gets whether the "writer_handle" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasWriterHandle { + get { return (_hasBits0 & 1) != 0; } + } + /// Clears the value of the "writer_handle" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearWriterHandle() { + _hasBits0 &= ~1; + } + + /// Field number for the "bytes" field. + public const int BytesFieldNumber = 2; + private readonly static pb::ByteString BytesDefaultValue = pb::ByteString.Empty; + + private pb::ByteString bytes_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pb::ByteString Bytes { + get { return bytes_ ?? BytesDefaultValue; } + set { + bytes_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + /// Gets whether the "bytes" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasBytes { + get { return bytes_ != null; } + } + /// Clears the value of the "bytes" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearBytes() { + bytes_ = null; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as ByteStreamWriterWriteRequest); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(ByteStreamWriterWriteRequest other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (WriterHandle != other.WriterHandle) return false; + if (Bytes != other.Bytes) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (HasWriterHandle) hash ^= WriterHandle.GetHashCode(); + if (HasBytes) hash ^= Bytes.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (HasWriterHandle) { + output.WriteRawTag(8); + output.WriteUInt64(WriterHandle); + } + if (HasBytes) { + output.WriteRawTag(18); + output.WriteBytes(Bytes); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (HasWriterHandle) { + output.WriteRawTag(8); + output.WriteUInt64(WriterHandle); + } + if (HasBytes) { + output.WriteRawTag(18); + output.WriteBytes(Bytes); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (HasWriterHandle) { + size += 1 + pb::CodedOutputStream.ComputeUInt64Size(WriterHandle); + } + if (HasBytes) { + size += 1 + pb::CodedOutputStream.ComputeBytesSize(Bytes); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(ByteStreamWriterWriteRequest other) { + if (other == null) { + return; + } + if (other.HasWriterHandle) { + WriterHandle = other.WriterHandle; + } + if (other.HasBytes) { + Bytes = other.Bytes; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + WriterHandle = input.ReadUInt64(); + break; + } + case 18: { + Bytes = input.ReadBytes(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + WriterHandle = input.ReadUInt64(); + break; + } + case 18: { + Bytes = input.ReadBytes(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class ByteStreamWriterWriteResponse : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ByteStreamWriterWriteResponse()); + private pb::UnknownFieldSet _unknownFields; + private int _hasBits0; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.DataStreamReflection.Descriptor.MessageTypes[32]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ByteStreamWriterWriteResponse() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ByteStreamWriterWriteResponse(ByteStreamWriterWriteResponse other) : this() { + _hasBits0 = other._hasBits0; + asyncId_ = other.asyncId_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ByteStreamWriterWriteResponse Clone() { + return new ByteStreamWriterWriteResponse(this); + } + + /// Field number for the "async_id" field. + public const int AsyncIdFieldNumber = 1; + private readonly static ulong AsyncIdDefaultValue = 0UL; + + private ulong asyncId_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ulong AsyncId { + get { if ((_hasBits0 & 1) != 0) { return asyncId_; } else { return AsyncIdDefaultValue; } } + set { + _hasBits0 |= 1; + asyncId_ = value; + } + } + /// Gets whether the "async_id" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasAsyncId { + get { return (_hasBits0 & 1) != 0; } + } + /// Clears the value of the "async_id" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearAsyncId() { + _hasBits0 &= ~1; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as ByteStreamWriterWriteResponse); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(ByteStreamWriterWriteResponse other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (AsyncId != other.AsyncId) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (HasAsyncId) hash ^= AsyncId.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (HasAsyncId) { + output.WriteRawTag(8); + output.WriteUInt64(AsyncId); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (HasAsyncId) { + output.WriteRawTag(8); + output.WriteUInt64(AsyncId); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (HasAsyncId) { + size += 1 + pb::CodedOutputStream.ComputeUInt64Size(AsyncId); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(ByteStreamWriterWriteResponse other) { + if (other == null) { + return; + } + if (other.HasAsyncId) { + AsyncId = other.AsyncId; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + AsyncId = input.ReadUInt64(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + AsyncId = input.ReadUInt64(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class ByteStreamWriterWriteCallback : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ByteStreamWriterWriteCallback()); + private pb::UnknownFieldSet _unknownFields; + private int _hasBits0; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.DataStreamReflection.Descriptor.MessageTypes[33]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ByteStreamWriterWriteCallback() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ByteStreamWriterWriteCallback(ByteStreamWriterWriteCallback other) : this() { + _hasBits0 = other._hasBits0; + asyncId_ = other.asyncId_; + error_ = other.error_ != null ? other.error_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ByteStreamWriterWriteCallback Clone() { + return new ByteStreamWriterWriteCallback(this); + } + + /// Field number for the "async_id" field. + public const int AsyncIdFieldNumber = 1; + private readonly static ulong AsyncIdDefaultValue = 0UL; + + private ulong asyncId_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ulong AsyncId { + get { if ((_hasBits0 & 1) != 0) { return asyncId_; } else { return AsyncIdDefaultValue; } } + set { + _hasBits0 |= 1; + asyncId_ = value; + } + } + /// Gets whether the "async_id" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasAsyncId { + get { return (_hasBits0 & 1) != 0; } + } + /// Clears the value of the "async_id" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearAsyncId() { + _hasBits0 &= ~1; + } + + /// Field number for the "error" field. + public const int ErrorFieldNumber = 2; + private global::LiveKit.Proto.StreamError error_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.StreamError Error { + get { return error_; } + set { + error_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as ByteStreamWriterWriteCallback); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(ByteStreamWriterWriteCallback other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (AsyncId != other.AsyncId) return false; + if (!object.Equals(Error, other.Error)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (HasAsyncId) hash ^= AsyncId.GetHashCode(); + if (error_ != null) hash ^= Error.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (HasAsyncId) { + output.WriteRawTag(8); + output.WriteUInt64(AsyncId); + } + if (error_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Error); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (HasAsyncId) { + output.WriteRawTag(8); + output.WriteUInt64(AsyncId); + } + if (error_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Error); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (HasAsyncId) { + size += 1 + pb::CodedOutputStream.ComputeUInt64Size(AsyncId); + } + if (error_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Error); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(ByteStreamWriterWriteCallback other) { + if (other == null) { + return; + } + if (other.HasAsyncId) { + AsyncId = other.AsyncId; + } + if (other.error_ != null) { + if (error_ == null) { + Error = new global::LiveKit.Proto.StreamError(); + } + Error.MergeFrom(other.Error); + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + AsyncId = input.ReadUInt64(); + break; + } + case 18: { + if (error_ == null) { + Error = new global::LiveKit.Proto.StreamError(); + } + input.ReadMessage(Error); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + AsyncId = input.ReadUInt64(); + break; + } + case 18: { + if (error_ == null) { + Error = new global::LiveKit.Proto.StreamError(); + } + input.ReadMessage(Error); + break; + } + } + } + } + #endif + + } + + /// + /// Closes a stream writer. + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class ByteStreamWriterCloseRequest : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ByteStreamWriterCloseRequest()); + private pb::UnknownFieldSet _unknownFields; + private int _hasBits0; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.DataStreamReflection.Descriptor.MessageTypes[34]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ByteStreamWriterCloseRequest() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ByteStreamWriterCloseRequest(ByteStreamWriterCloseRequest other) : this() { + _hasBits0 = other._hasBits0; + writerHandle_ = other.writerHandle_; + reason_ = other.reason_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ByteStreamWriterCloseRequest Clone() { + return new ByteStreamWriterCloseRequest(this); + } + + /// Field number for the "writer_handle" field. + public const int WriterHandleFieldNumber = 1; + private readonly static ulong WriterHandleDefaultValue = 0UL; + + private ulong writerHandle_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ulong WriterHandle { + get { if ((_hasBits0 & 1) != 0) { return writerHandle_; } else { return WriterHandleDefaultValue; } } + set { + _hasBits0 |= 1; + writerHandle_ = value; + } + } + /// Gets whether the "writer_handle" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasWriterHandle { + get { return (_hasBits0 & 1) != 0; } + } + /// Clears the value of the "writer_handle" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearWriterHandle() { + _hasBits0 &= ~1; + } + + /// Field number for the "reason" field. + public const int ReasonFieldNumber = 2; + private readonly static string ReasonDefaultValue = ""; + + private string reason_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Reason { + get { return reason_ ?? ReasonDefaultValue; } + set { + reason_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + /// Gets whether the "reason" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasReason { + get { return reason_ != null; } + } + /// Clears the value of the "reason" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearReason() { + reason_ = null; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as ByteStreamWriterCloseRequest); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(ByteStreamWriterCloseRequest other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (WriterHandle != other.WriterHandle) return false; + if (Reason != other.Reason) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (HasWriterHandle) hash ^= WriterHandle.GetHashCode(); + if (HasReason) hash ^= Reason.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (HasWriterHandle) { + output.WriteRawTag(8); + output.WriteUInt64(WriterHandle); + } + if (HasReason) { + output.WriteRawTag(18); + output.WriteString(Reason); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (HasWriterHandle) { + output.WriteRawTag(8); + output.WriteUInt64(WriterHandle); + } + if (HasReason) { + output.WriteRawTag(18); + output.WriteString(Reason); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (HasWriterHandle) { + size += 1 + pb::CodedOutputStream.ComputeUInt64Size(WriterHandle); + } + if (HasReason) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Reason); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(ByteStreamWriterCloseRequest other) { + if (other == null) { + return; + } + if (other.HasWriterHandle) { + WriterHandle = other.WriterHandle; + } + if (other.HasReason) { + Reason = other.Reason; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + WriterHandle = input.ReadUInt64(); + break; + } + case 18: { + Reason = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + WriterHandle = input.ReadUInt64(); + break; + } + case 18: { + Reason = input.ReadString(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class ByteStreamWriterCloseResponse : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ByteStreamWriterCloseResponse()); + private pb::UnknownFieldSet _unknownFields; + private int _hasBits0; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.DataStreamReflection.Descriptor.MessageTypes[35]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ByteStreamWriterCloseResponse() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ByteStreamWriterCloseResponse(ByteStreamWriterCloseResponse other) : this() { + _hasBits0 = other._hasBits0; + asyncId_ = other.asyncId_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ByteStreamWriterCloseResponse Clone() { + return new ByteStreamWriterCloseResponse(this); + } + + /// Field number for the "async_id" field. + public const int AsyncIdFieldNumber = 1; + private readonly static ulong AsyncIdDefaultValue = 0UL; + + private ulong asyncId_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ulong AsyncId { + get { if ((_hasBits0 & 1) != 0) { return asyncId_; } else { return AsyncIdDefaultValue; } } + set { + _hasBits0 |= 1; + asyncId_ = value; + } + } + /// Gets whether the "async_id" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasAsyncId { + get { return (_hasBits0 & 1) != 0; } + } + /// Clears the value of the "async_id" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearAsyncId() { + _hasBits0 &= ~1; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as ByteStreamWriterCloseResponse); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(ByteStreamWriterCloseResponse other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (AsyncId != other.AsyncId) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (HasAsyncId) hash ^= AsyncId.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (HasAsyncId) { + output.WriteRawTag(8); + output.WriteUInt64(AsyncId); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (HasAsyncId) { + output.WriteRawTag(8); + output.WriteUInt64(AsyncId); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (HasAsyncId) { + size += 1 + pb::CodedOutputStream.ComputeUInt64Size(AsyncId); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(ByteStreamWriterCloseResponse other) { + if (other == null) { + return; + } + if (other.HasAsyncId) { + AsyncId = other.AsyncId; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + AsyncId = input.ReadUInt64(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + AsyncId = input.ReadUInt64(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class ByteStreamWriterCloseCallback : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ByteStreamWriterCloseCallback()); + private pb::UnknownFieldSet _unknownFields; + private int _hasBits0; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.DataStreamReflection.Descriptor.MessageTypes[36]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ByteStreamWriterCloseCallback() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ByteStreamWriterCloseCallback(ByteStreamWriterCloseCallback other) : this() { + _hasBits0 = other._hasBits0; + asyncId_ = other.asyncId_; + error_ = other.error_ != null ? other.error_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ByteStreamWriterCloseCallback Clone() { + return new ByteStreamWriterCloseCallback(this); + } + + /// Field number for the "async_id" field. + public const int AsyncIdFieldNumber = 1; + private readonly static ulong AsyncIdDefaultValue = 0UL; + + private ulong asyncId_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ulong AsyncId { + get { if ((_hasBits0 & 1) != 0) { return asyncId_; } else { return AsyncIdDefaultValue; } } + set { + _hasBits0 |= 1; + asyncId_ = value; + } + } + /// Gets whether the "async_id" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasAsyncId { + get { return (_hasBits0 & 1) != 0; } + } + /// Clears the value of the "async_id" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearAsyncId() { + _hasBits0 &= ~1; + } + + /// Field number for the "error" field. + public const int ErrorFieldNumber = 2; + private global::LiveKit.Proto.StreamError error_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.StreamError Error { + get { return error_; } + set { + error_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as ByteStreamWriterCloseCallback); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(ByteStreamWriterCloseCallback other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (AsyncId != other.AsyncId) return false; + if (!object.Equals(Error, other.Error)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (HasAsyncId) hash ^= AsyncId.GetHashCode(); + if (error_ != null) hash ^= Error.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (HasAsyncId) { + output.WriteRawTag(8); + output.WriteUInt64(AsyncId); + } + if (error_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Error); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (HasAsyncId) { + output.WriteRawTag(8); + output.WriteUInt64(AsyncId); + } + if (error_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Error); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (HasAsyncId) { + size += 1 + pb::CodedOutputStream.ComputeUInt64Size(AsyncId); + } + if (error_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Error); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(ByteStreamWriterCloseCallback other) { + if (other == null) { + return; + } + if (other.HasAsyncId) { + AsyncId = other.AsyncId; + } + if (other.error_ != null) { + if (error_ == null) { + Error = new global::LiveKit.Proto.StreamError(); + } + Error.MergeFrom(other.Error); + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + AsyncId = input.ReadUInt64(); + break; + } + case 18: { + if (error_ == null) { + Error = new global::LiveKit.Proto.StreamError(); + } + input.ReadMessage(Error); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + AsyncId = input.ReadUInt64(); + break; + } + case 18: { + if (error_ == null) { + Error = new global::LiveKit.Proto.StreamError(); + } + input.ReadMessage(Error); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class OwnedTextStreamWriter : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new OwnedTextStreamWriter()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.DataStreamReflection.Descriptor.MessageTypes[37]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public OwnedTextStreamWriter() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public OwnedTextStreamWriter(OwnedTextStreamWriter other) : this() { + handle_ = other.handle_ != null ? other.handle_.Clone() : null; + info_ = other.info_ != null ? other.info_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public OwnedTextStreamWriter Clone() { + return new OwnedTextStreamWriter(this); + } + + /// Field number for the "handle" field. + public const int HandleFieldNumber = 1; + private global::LiveKit.Proto.FfiOwnedHandle handle_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.FfiOwnedHandle Handle { + get { return handle_; } + set { + handle_ = value; + } + } + + /// Field number for the "info" field. + public const int InfoFieldNumber = 2; + private global::LiveKit.Proto.TextStreamInfo info_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.TextStreamInfo Info { + get { return info_; } + set { + info_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as OwnedTextStreamWriter); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(OwnedTextStreamWriter other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (!object.Equals(Handle, other.Handle)) return false; + if (!object.Equals(Info, other.Info)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (handle_ != null) hash ^= Handle.GetHashCode(); + if (info_ != null) hash ^= Info.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (handle_ != null) { + output.WriteRawTag(10); + output.WriteMessage(Handle); + } + if (info_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Info); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (handle_ != null) { + output.WriteRawTag(10); + output.WriteMessage(Handle); + } + if (info_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Info); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (handle_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Handle); + } + if (info_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Info); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(OwnedTextStreamWriter other) { + if (other == null) { + return; + } + if (other.handle_ != null) { + if (handle_ == null) { + Handle = new global::LiveKit.Proto.FfiOwnedHandle(); + } + Handle.MergeFrom(other.Handle); + } + if (other.info_ != null) { + if (info_ == null) { + Info = new global::LiveKit.Proto.TextStreamInfo(); + } + Info.MergeFrom(other.Info); + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + if (handle_ == null) { + Handle = new global::LiveKit.Proto.FfiOwnedHandle(); + } + input.ReadMessage(Handle); + break; + } + case 18: { + if (info_ == null) { + Info = new global::LiveKit.Proto.TextStreamInfo(); + } + input.ReadMessage(Info); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + if (handle_ == null) { + Handle = new global::LiveKit.Proto.FfiOwnedHandle(); + } + input.ReadMessage(Handle); + break; + } + case 18: { + if (info_ == null) { + Info = new global::LiveKit.Proto.TextStreamInfo(); + } + input.ReadMessage(Info); + break; + } + } + } + } + #endif + + } + + /// + /// Opens an outgoing text stream. + /// Call must be balanced with a TextStreamCloseRequest. + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class TextStreamOpenRequest : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new TextStreamOpenRequest()); + private pb::UnknownFieldSet _unknownFields; + private int _hasBits0; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.DataStreamReflection.Descriptor.MessageTypes[38]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TextStreamOpenRequest() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TextStreamOpenRequest(TextStreamOpenRequest other) : this() { + _hasBits0 = other._hasBits0; + localParticipantHandle_ = other.localParticipantHandle_; + options_ = other.options_ != null ? other.options_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TextStreamOpenRequest Clone() { + return new TextStreamOpenRequest(this); + } + + /// Field number for the "local_participant_handle" field. + public const int LocalParticipantHandleFieldNumber = 1; + private readonly static ulong LocalParticipantHandleDefaultValue = 0UL; + + private ulong localParticipantHandle_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ulong LocalParticipantHandle { + get { if ((_hasBits0 & 1) != 0) { return localParticipantHandle_; } else { return LocalParticipantHandleDefaultValue; } } + set { + _hasBits0 |= 1; + localParticipantHandle_ = value; + } + } + /// Gets whether the "local_participant_handle" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasLocalParticipantHandle { + get { return (_hasBits0 & 1) != 0; } + } + /// Clears the value of the "local_participant_handle" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearLocalParticipantHandle() { + _hasBits0 &= ~1; + } + + /// Field number for the "options" field. + public const int OptionsFieldNumber = 2; + private global::LiveKit.Proto.StreamTextOptions options_; + /// + /// Options to use for opening the stream. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.StreamTextOptions Options { + get { return options_; } + set { + options_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as TextStreamOpenRequest); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(TextStreamOpenRequest other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (LocalParticipantHandle != other.LocalParticipantHandle) return false; + if (!object.Equals(Options, other.Options)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (HasLocalParticipantHandle) hash ^= LocalParticipantHandle.GetHashCode(); + if (options_ != null) hash ^= Options.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (HasLocalParticipantHandle) { + output.WriteRawTag(8); + output.WriteUInt64(LocalParticipantHandle); + } + if (options_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Options); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (HasLocalParticipantHandle) { + output.WriteRawTag(8); + output.WriteUInt64(LocalParticipantHandle); + } + if (options_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Options); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (HasLocalParticipantHandle) { + size += 1 + pb::CodedOutputStream.ComputeUInt64Size(LocalParticipantHandle); + } + if (options_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Options); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(TextStreamOpenRequest other) { + if (other == null) { + return; + } + if (other.HasLocalParticipantHandle) { + LocalParticipantHandle = other.LocalParticipantHandle; + } + if (other.options_ != null) { + if (options_ == null) { + Options = new global::LiveKit.Proto.StreamTextOptions(); + } + Options.MergeFrom(other.Options); + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + LocalParticipantHandle = input.ReadUInt64(); + break; + } + case 18: { + if (options_ == null) { + Options = new global::LiveKit.Proto.StreamTextOptions(); + } + input.ReadMessage(Options); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + LocalParticipantHandle = input.ReadUInt64(); + break; + } + case 18: { + if (options_ == null) { + Options = new global::LiveKit.Proto.StreamTextOptions(); + } + input.ReadMessage(Options); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class TextStreamOpenResponse : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new TextStreamOpenResponse()); + private pb::UnknownFieldSet _unknownFields; + private int _hasBits0; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.DataStreamReflection.Descriptor.MessageTypes[39]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TextStreamOpenResponse() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TextStreamOpenResponse(TextStreamOpenResponse other) : this() { + _hasBits0 = other._hasBits0; + asyncId_ = other.asyncId_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TextStreamOpenResponse Clone() { + return new TextStreamOpenResponse(this); + } + + /// Field number for the "async_id" field. + public const int AsyncIdFieldNumber = 1; + private readonly static ulong AsyncIdDefaultValue = 0UL; + + private ulong asyncId_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ulong AsyncId { + get { if ((_hasBits0 & 1) != 0) { return asyncId_; } else { return AsyncIdDefaultValue; } } + set { + _hasBits0 |= 1; + asyncId_ = value; + } + } + /// Gets whether the "async_id" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasAsyncId { + get { return (_hasBits0 & 1) != 0; } + } + /// Clears the value of the "async_id" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearAsyncId() { + _hasBits0 &= ~1; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as TextStreamOpenResponse); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(TextStreamOpenResponse other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (AsyncId != other.AsyncId) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (HasAsyncId) hash ^= AsyncId.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (HasAsyncId) { + output.WriteRawTag(8); + output.WriteUInt64(AsyncId); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (HasAsyncId) { + output.WriteRawTag(8); + output.WriteUInt64(AsyncId); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (HasAsyncId) { + size += 1 + pb::CodedOutputStream.ComputeUInt64Size(AsyncId); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(TextStreamOpenResponse other) { + if (other == null) { + return; + } + if (other.HasAsyncId) { + AsyncId = other.AsyncId; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + AsyncId = input.ReadUInt64(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + AsyncId = input.ReadUInt64(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class TextStreamOpenCallback : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new TextStreamOpenCallback()); + private pb::UnknownFieldSet _unknownFields; + private int _hasBits0; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.DataStreamReflection.Descriptor.MessageTypes[40]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TextStreamOpenCallback() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TextStreamOpenCallback(TextStreamOpenCallback other) : this() { + _hasBits0 = other._hasBits0; + asyncId_ = other.asyncId_; + switch (other.ResultCase) { + case ResultOneofCase.Writer: + Writer = other.Writer.Clone(); + break; + case ResultOneofCase.Error: + Error = other.Error.Clone(); + break; + } + + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TextStreamOpenCallback Clone() { + return new TextStreamOpenCallback(this); + } + + /// Field number for the "async_id" field. + public const int AsyncIdFieldNumber = 1; + private readonly static ulong AsyncIdDefaultValue = 0UL; + + private ulong asyncId_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ulong AsyncId { + get { if ((_hasBits0 & 1) != 0) { return asyncId_; } else { return AsyncIdDefaultValue; } } + set { + _hasBits0 |= 1; + asyncId_ = value; + } + } + /// Gets whether the "async_id" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasAsyncId { + get { return (_hasBits0 & 1) != 0; } + } + /// Clears the value of the "async_id" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearAsyncId() { + _hasBits0 &= ~1; + } + + /// Field number for the "writer" field. + public const int WriterFieldNumber = 2; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.OwnedTextStreamWriter Writer { + get { return resultCase_ == ResultOneofCase.Writer ? (global::LiveKit.Proto.OwnedTextStreamWriter) result_ : null; } + set { + result_ = value; + resultCase_ = value == null ? ResultOneofCase.None : ResultOneofCase.Writer; + } + } + + /// Field number for the "error" field. + public const int ErrorFieldNumber = 3; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.StreamError Error { + get { return resultCase_ == ResultOneofCase.Error ? (global::LiveKit.Proto.StreamError) result_ : null; } + set { + result_ = value; + resultCase_ = value == null ? ResultOneofCase.None : ResultOneofCase.Error; + } + } + + private object result_; + /// Enum of possible cases for the "result" oneof. + public enum ResultOneofCase { + None = 0, + Writer = 2, + Error = 3, + } + private ResultOneofCase resultCase_ = ResultOneofCase.None; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ResultOneofCase ResultCase { + get { return resultCase_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearResult() { + resultCase_ = ResultOneofCase.None; + result_ = null; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as TextStreamOpenCallback); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(TextStreamOpenCallback other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (AsyncId != other.AsyncId) return false; + if (!object.Equals(Writer, other.Writer)) return false; + if (!object.Equals(Error, other.Error)) return false; + if (ResultCase != other.ResultCase) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (HasAsyncId) hash ^= AsyncId.GetHashCode(); + if (resultCase_ == ResultOneofCase.Writer) hash ^= Writer.GetHashCode(); + if (resultCase_ == ResultOneofCase.Error) hash ^= Error.GetHashCode(); + hash ^= (int) resultCase_; + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (HasAsyncId) { + output.WriteRawTag(8); + output.WriteUInt64(AsyncId); + } + if (resultCase_ == ResultOneofCase.Writer) { + output.WriteRawTag(18); + output.WriteMessage(Writer); + } + if (resultCase_ == ResultOneofCase.Error) { + output.WriteRawTag(26); + output.WriteMessage(Error); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (HasAsyncId) { + output.WriteRawTag(8); + output.WriteUInt64(AsyncId); + } + if (resultCase_ == ResultOneofCase.Writer) { + output.WriteRawTag(18); + output.WriteMessage(Writer); + } + if (resultCase_ == ResultOneofCase.Error) { + output.WriteRawTag(26); + output.WriteMessage(Error); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (HasAsyncId) { + size += 1 + pb::CodedOutputStream.ComputeUInt64Size(AsyncId); + } + if (resultCase_ == ResultOneofCase.Writer) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Writer); + } + if (resultCase_ == ResultOneofCase.Error) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Error); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(TextStreamOpenCallback other) { + if (other == null) { + return; + } + if (other.HasAsyncId) { + AsyncId = other.AsyncId; + } + switch (other.ResultCase) { + case ResultOneofCase.Writer: + if (Writer == null) { + Writer = new global::LiveKit.Proto.OwnedTextStreamWriter(); + } + Writer.MergeFrom(other.Writer); + break; + case ResultOneofCase.Error: + if (Error == null) { + Error = new global::LiveKit.Proto.StreamError(); + } + Error.MergeFrom(other.Error); + break; + } + + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + AsyncId = input.ReadUInt64(); + break; + } + case 18: { + global::LiveKit.Proto.OwnedTextStreamWriter subBuilder = new global::LiveKit.Proto.OwnedTextStreamWriter(); + if (resultCase_ == ResultOneofCase.Writer) { + subBuilder.MergeFrom(Writer); + } + input.ReadMessage(subBuilder); + Writer = subBuilder; + break; + } + case 26: { + global::LiveKit.Proto.StreamError subBuilder = new global::LiveKit.Proto.StreamError(); + if (resultCase_ == ResultOneofCase.Error) { + subBuilder.MergeFrom(Error); + } + input.ReadMessage(subBuilder); + Error = subBuilder; + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + AsyncId = input.ReadUInt64(); + break; + } + case 18: { + global::LiveKit.Proto.OwnedTextStreamWriter subBuilder = new global::LiveKit.Proto.OwnedTextStreamWriter(); + if (resultCase_ == ResultOneofCase.Writer) { + subBuilder.MergeFrom(Writer); + } + input.ReadMessage(subBuilder); + Writer = subBuilder; + break; + } + case 26: { + global::LiveKit.Proto.StreamError subBuilder = new global::LiveKit.Proto.StreamError(); + if (resultCase_ == ResultOneofCase.Error) { + subBuilder.MergeFrom(Error); + } + input.ReadMessage(subBuilder); + Error = subBuilder; + break; + } + } + } + } + #endif + + } + + /// + /// Writes text to a text stream writer. + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class TextStreamWriterWriteRequest : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new TextStreamWriterWriteRequest()); + private pb::UnknownFieldSet _unknownFields; + private int _hasBits0; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.DataStreamReflection.Descriptor.MessageTypes[41]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TextStreamWriterWriteRequest() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TextStreamWriterWriteRequest(TextStreamWriterWriteRequest other) : this() { + _hasBits0 = other._hasBits0; + writerHandle_ = other.writerHandle_; + text_ = other.text_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TextStreamWriterWriteRequest Clone() { + return new TextStreamWriterWriteRequest(this); + } + + /// Field number for the "writer_handle" field. + public const int WriterHandleFieldNumber = 1; + private readonly static ulong WriterHandleDefaultValue = 0UL; + + private ulong writerHandle_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ulong WriterHandle { + get { if ((_hasBits0 & 1) != 0) { return writerHandle_; } else { return WriterHandleDefaultValue; } } + set { + _hasBits0 |= 1; + writerHandle_ = value; + } + } + /// Gets whether the "writer_handle" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasWriterHandle { + get { return (_hasBits0 & 1) != 0; } + } + /// Clears the value of the "writer_handle" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearWriterHandle() { + _hasBits0 &= ~1; + } + + /// Field number for the "text" field. + public const int TextFieldNumber = 2; + private readonly static string TextDefaultValue = ""; + + private string text_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Text { + get { return text_ ?? TextDefaultValue; } + set { + text_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + /// Gets whether the "text" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasText { + get { return text_ != null; } + } + /// Clears the value of the "text" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearText() { + text_ = null; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as TextStreamWriterWriteRequest); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(TextStreamWriterWriteRequest other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (WriterHandle != other.WriterHandle) return false; + if (Text != other.Text) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (HasWriterHandle) hash ^= WriterHandle.GetHashCode(); + if (HasText) hash ^= Text.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (HasWriterHandle) { + output.WriteRawTag(8); + output.WriteUInt64(WriterHandle); + } + if (HasText) { + output.WriteRawTag(18); + output.WriteString(Text); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (HasWriterHandle) { + output.WriteRawTag(8); + output.WriteUInt64(WriterHandle); + } + if (HasText) { + output.WriteRawTag(18); + output.WriteString(Text); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (HasWriterHandle) { + size += 1 + pb::CodedOutputStream.ComputeUInt64Size(WriterHandle); + } + if (HasText) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Text); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(TextStreamWriterWriteRequest other) { + if (other == null) { + return; + } + if (other.HasWriterHandle) { + WriterHandle = other.WriterHandle; + } + if (other.HasText) { + Text = other.Text; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + WriterHandle = input.ReadUInt64(); + break; + } + case 18: { + Text = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + WriterHandle = input.ReadUInt64(); + break; + } + case 18: { + Text = input.ReadString(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class TextStreamWriterWriteResponse : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new TextStreamWriterWriteResponse()); + private pb::UnknownFieldSet _unknownFields; + private int _hasBits0; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.DataStreamReflection.Descriptor.MessageTypes[42]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TextStreamWriterWriteResponse() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TextStreamWriterWriteResponse(TextStreamWriterWriteResponse other) : this() { + _hasBits0 = other._hasBits0; + asyncId_ = other.asyncId_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TextStreamWriterWriteResponse Clone() { + return new TextStreamWriterWriteResponse(this); + } + + /// Field number for the "async_id" field. + public const int AsyncIdFieldNumber = 1; + private readonly static ulong AsyncIdDefaultValue = 0UL; + + private ulong asyncId_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ulong AsyncId { + get { if ((_hasBits0 & 1) != 0) { return asyncId_; } else { return AsyncIdDefaultValue; } } + set { + _hasBits0 |= 1; + asyncId_ = value; + } + } + /// Gets whether the "async_id" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasAsyncId { + get { return (_hasBits0 & 1) != 0; } + } + /// Clears the value of the "async_id" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearAsyncId() { + _hasBits0 &= ~1; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as TextStreamWriterWriteResponse); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(TextStreamWriterWriteResponse other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (AsyncId != other.AsyncId) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (HasAsyncId) hash ^= AsyncId.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (HasAsyncId) { + output.WriteRawTag(8); + output.WriteUInt64(AsyncId); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (HasAsyncId) { + output.WriteRawTag(8); + output.WriteUInt64(AsyncId); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (HasAsyncId) { + size += 1 + pb::CodedOutputStream.ComputeUInt64Size(AsyncId); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(TextStreamWriterWriteResponse other) { + if (other == null) { + return; + } + if (other.HasAsyncId) { + AsyncId = other.AsyncId; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + AsyncId = input.ReadUInt64(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + AsyncId = input.ReadUInt64(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class TextStreamWriterWriteCallback : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new TextStreamWriterWriteCallback()); + private pb::UnknownFieldSet _unknownFields; + private int _hasBits0; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.DataStreamReflection.Descriptor.MessageTypes[43]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TextStreamWriterWriteCallback() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TextStreamWriterWriteCallback(TextStreamWriterWriteCallback other) : this() { + _hasBits0 = other._hasBits0; + asyncId_ = other.asyncId_; + error_ = other.error_ != null ? other.error_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TextStreamWriterWriteCallback Clone() { + return new TextStreamWriterWriteCallback(this); + } + + /// Field number for the "async_id" field. + public const int AsyncIdFieldNumber = 1; + private readonly static ulong AsyncIdDefaultValue = 0UL; + + private ulong asyncId_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ulong AsyncId { + get { if ((_hasBits0 & 1) != 0) { return asyncId_; } else { return AsyncIdDefaultValue; } } + set { + _hasBits0 |= 1; + asyncId_ = value; + } + } + /// Gets whether the "async_id" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasAsyncId { + get { return (_hasBits0 & 1) != 0; } + } + /// Clears the value of the "async_id" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearAsyncId() { + _hasBits0 &= ~1; + } + + /// Field number for the "error" field. + public const int ErrorFieldNumber = 2; + private global::LiveKit.Proto.StreamError error_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.StreamError Error { + get { return error_; } + set { + error_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as TextStreamWriterWriteCallback); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(TextStreamWriterWriteCallback other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (AsyncId != other.AsyncId) return false; + if (!object.Equals(Error, other.Error)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (HasAsyncId) hash ^= AsyncId.GetHashCode(); + if (error_ != null) hash ^= Error.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (HasAsyncId) { + output.WriteRawTag(8); + output.WriteUInt64(AsyncId); + } + if (error_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Error); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (HasAsyncId) { + output.WriteRawTag(8); + output.WriteUInt64(AsyncId); + } + if (error_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Error); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (HasAsyncId) { + size += 1 + pb::CodedOutputStream.ComputeUInt64Size(AsyncId); + } + if (error_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Error); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(TextStreamWriterWriteCallback other) { + if (other == null) { + return; + } + if (other.HasAsyncId) { + AsyncId = other.AsyncId; + } + if (other.error_ != null) { + if (error_ == null) { + Error = new global::LiveKit.Proto.StreamError(); + } + Error.MergeFrom(other.Error); + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + AsyncId = input.ReadUInt64(); + break; + } + case 18: { + if (error_ == null) { + Error = new global::LiveKit.Proto.StreamError(); + } + input.ReadMessage(Error); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + AsyncId = input.ReadUInt64(); + break; + } + case 18: { + if (error_ == null) { + Error = new global::LiveKit.Proto.StreamError(); + } + input.ReadMessage(Error); + break; + } + } + } + } + #endif + + } + + /// + /// Closes a text stream writer. + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class TextStreamWriterCloseRequest : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new TextStreamWriterCloseRequest()); + private pb::UnknownFieldSet _unknownFields; + private int _hasBits0; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.DataStreamReflection.Descriptor.MessageTypes[44]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TextStreamWriterCloseRequest() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TextStreamWriterCloseRequest(TextStreamWriterCloseRequest other) : this() { + _hasBits0 = other._hasBits0; + writerHandle_ = other.writerHandle_; + reason_ = other.reason_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TextStreamWriterCloseRequest Clone() { + return new TextStreamWriterCloseRequest(this); + } + + /// Field number for the "writer_handle" field. + public const int WriterHandleFieldNumber = 1; + private readonly static ulong WriterHandleDefaultValue = 0UL; + + private ulong writerHandle_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ulong WriterHandle { + get { if ((_hasBits0 & 1) != 0) { return writerHandle_; } else { return WriterHandleDefaultValue; } } + set { + _hasBits0 |= 1; + writerHandle_ = value; + } + } + /// Gets whether the "writer_handle" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasWriterHandle { + get { return (_hasBits0 & 1) != 0; } + } + /// Clears the value of the "writer_handle" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearWriterHandle() { + _hasBits0 &= ~1; + } + + /// Field number for the "reason" field. + public const int ReasonFieldNumber = 2; + private readonly static string ReasonDefaultValue = ""; + + private string reason_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Reason { + get { return reason_ ?? ReasonDefaultValue; } + set { + reason_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + /// Gets whether the "reason" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasReason { + get { return reason_ != null; } + } + /// Clears the value of the "reason" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearReason() { + reason_ = null; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as TextStreamWriterCloseRequest); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(TextStreamWriterCloseRequest other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (WriterHandle != other.WriterHandle) return false; + if (Reason != other.Reason) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (HasWriterHandle) hash ^= WriterHandle.GetHashCode(); + if (HasReason) hash ^= Reason.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (HasWriterHandle) { + output.WriteRawTag(8); + output.WriteUInt64(WriterHandle); + } + if (HasReason) { + output.WriteRawTag(18); + output.WriteString(Reason); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (HasWriterHandle) { + output.WriteRawTag(8); + output.WriteUInt64(WriterHandle); + } + if (HasReason) { + output.WriteRawTag(18); + output.WriteString(Reason); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (HasWriterHandle) { + size += 1 + pb::CodedOutputStream.ComputeUInt64Size(WriterHandle); + } + if (HasReason) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Reason); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(TextStreamWriterCloseRequest other) { + if (other == null) { + return; + } + if (other.HasWriterHandle) { + WriterHandle = other.WriterHandle; + } + if (other.HasReason) { + Reason = other.Reason; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + WriterHandle = input.ReadUInt64(); + break; + } + case 18: { + Reason = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + WriterHandle = input.ReadUInt64(); + break; + } + case 18: { + Reason = input.ReadString(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class TextStreamWriterCloseResponse : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new TextStreamWriterCloseResponse()); + private pb::UnknownFieldSet _unknownFields; + private int _hasBits0; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.DataStreamReflection.Descriptor.MessageTypes[45]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TextStreamWriterCloseResponse() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TextStreamWriterCloseResponse(TextStreamWriterCloseResponse other) : this() { + _hasBits0 = other._hasBits0; + asyncId_ = other.asyncId_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TextStreamWriterCloseResponse Clone() { + return new TextStreamWriterCloseResponse(this); + } + + /// Field number for the "async_id" field. + public const int AsyncIdFieldNumber = 1; + private readonly static ulong AsyncIdDefaultValue = 0UL; + + private ulong asyncId_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ulong AsyncId { + get { if ((_hasBits0 & 1) != 0) { return asyncId_; } else { return AsyncIdDefaultValue; } } + set { + _hasBits0 |= 1; + asyncId_ = value; + } + } + /// Gets whether the "async_id" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasAsyncId { + get { return (_hasBits0 & 1) != 0; } + } + /// Clears the value of the "async_id" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearAsyncId() { + _hasBits0 &= ~1; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as TextStreamWriterCloseResponse); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(TextStreamWriterCloseResponse other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (AsyncId != other.AsyncId) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (HasAsyncId) hash ^= AsyncId.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (HasAsyncId) { + output.WriteRawTag(8); + output.WriteUInt64(AsyncId); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (HasAsyncId) { + output.WriteRawTag(8); + output.WriteUInt64(AsyncId); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (HasAsyncId) { + size += 1 + pb::CodedOutputStream.ComputeUInt64Size(AsyncId); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(TextStreamWriterCloseResponse other) { + if (other == null) { + return; + } + if (other.HasAsyncId) { + AsyncId = other.AsyncId; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + AsyncId = input.ReadUInt64(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + AsyncId = input.ReadUInt64(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class TextStreamWriterCloseCallback : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new TextStreamWriterCloseCallback()); + private pb::UnknownFieldSet _unknownFields; + private int _hasBits0; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.DataStreamReflection.Descriptor.MessageTypes[46]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TextStreamWriterCloseCallback() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TextStreamWriterCloseCallback(TextStreamWriterCloseCallback other) : this() { + _hasBits0 = other._hasBits0; + asyncId_ = other.asyncId_; + error_ = other.error_ != null ? other.error_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TextStreamWriterCloseCallback Clone() { + return new TextStreamWriterCloseCallback(this); + } + + /// Field number for the "async_id" field. + public const int AsyncIdFieldNumber = 1; + private readonly static ulong AsyncIdDefaultValue = 0UL; + + private ulong asyncId_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ulong AsyncId { + get { if ((_hasBits0 & 1) != 0) { return asyncId_; } else { return AsyncIdDefaultValue; } } + set { + _hasBits0 |= 1; + asyncId_ = value; + } + } + /// Gets whether the "async_id" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasAsyncId { + get { return (_hasBits0 & 1) != 0; } + } + /// Clears the value of the "async_id" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearAsyncId() { + _hasBits0 &= ~1; + } + + /// Field number for the "error" field. + public const int ErrorFieldNumber = 2; + private global::LiveKit.Proto.StreamError error_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.StreamError Error { + get { return error_; } + set { + error_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as TextStreamWriterCloseCallback); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(TextStreamWriterCloseCallback other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (AsyncId != other.AsyncId) return false; + if (!object.Equals(Error, other.Error)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (HasAsyncId) hash ^= AsyncId.GetHashCode(); + if (error_ != null) hash ^= Error.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (HasAsyncId) { + output.WriteRawTag(8); + output.WriteUInt64(AsyncId); + } + if (error_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Error); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (HasAsyncId) { + output.WriteRawTag(8); + output.WriteUInt64(AsyncId); + } + if (error_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Error); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (HasAsyncId) { + size += 1 + pb::CodedOutputStream.ComputeUInt64Size(AsyncId); + } + if (error_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Error); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(TextStreamWriterCloseCallback other) { + if (other == null) { + return; + } + if (other.HasAsyncId) { + AsyncId = other.AsyncId; + } + if (other.error_ != null) { + if (error_ == null) { + Error = new global::LiveKit.Proto.StreamError(); + } + Error.MergeFrom(other.Error); + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + AsyncId = input.ReadUInt64(); + break; + } + case 18: { + if (error_ == null) { + Error = new global::LiveKit.Proto.StreamError(); + } + input.ReadMessage(Error); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + AsyncId = input.ReadUInt64(); + break; + } + case 18: { + if (error_ == null) { + Error = new global::LiveKit.Proto.StreamError(); + } + input.ReadMessage(Error); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class TextStreamInfo : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new TextStreamInfo()); + private pb::UnknownFieldSet _unknownFields; + private int _hasBits0; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.DataStreamReflection.Descriptor.MessageTypes[47]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TextStreamInfo() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TextStreamInfo(TextStreamInfo other) : this() { + _hasBits0 = other._hasBits0; + streamId_ = other.streamId_; + timestamp_ = other.timestamp_; + mimeType_ = other.mimeType_; + topic_ = other.topic_; + totalLength_ = other.totalLength_; + attributes_ = other.attributes_.Clone(); + operationType_ = other.operationType_; + version_ = other.version_; + replyToStreamId_ = other.replyToStreamId_; + attachedStreamIds_ = other.attachedStreamIds_.Clone(); + generated_ = other.generated_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TextStreamInfo Clone() { + return new TextStreamInfo(this); + } + + /// Field number for the "stream_id" field. + public const int StreamIdFieldNumber = 1; + private readonly static string StreamIdDefaultValue = ""; + + private string streamId_; + /// + /// unique identifier for this data stream + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string StreamId { + get { return streamId_ ?? StreamIdDefaultValue; } + set { + streamId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + /// Gets whether the "stream_id" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasStreamId { + get { return streamId_ != null; } + } + /// Clears the value of the "stream_id" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearStreamId() { + streamId_ = null; + } + + /// Field number for the "timestamp" field. + public const int TimestampFieldNumber = 2; + private readonly static long TimestampDefaultValue = 0L; + + private long timestamp_; + /// + /// using int64 for Unix timestamp + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public long Timestamp { + get { if ((_hasBits0 & 1) != 0) { return timestamp_; } else { return TimestampDefaultValue; } } + set { + _hasBits0 |= 1; + timestamp_ = value; + } + } + /// Gets whether the "timestamp" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasTimestamp { + get { return (_hasBits0 & 1) != 0; } + } + /// Clears the value of the "timestamp" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearTimestamp() { + _hasBits0 &= ~1; + } + + /// Field number for the "mime_type" field. + public const int MimeTypeFieldNumber = 3; + private readonly static string MimeTypeDefaultValue = ""; + + private string mimeType_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string MimeType { + get { return mimeType_ ?? MimeTypeDefaultValue; } + set { + mimeType_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + /// Gets whether the "mime_type" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasMimeType { + get { return mimeType_ != null; } + } + /// Clears the value of the "mime_type" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearMimeType() { + mimeType_ = null; + } + + /// Field number for the "topic" field. + public const int TopicFieldNumber = 4; + private readonly static string TopicDefaultValue = ""; + + private string topic_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Topic { + get { return topic_ ?? TopicDefaultValue; } + set { + topic_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + /// Gets whether the "topic" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasTopic { + get { return topic_ != null; } + } + /// Clears the value of the "topic" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearTopic() { + topic_ = null; + } + + /// Field number for the "total_length" field. + public const int TotalLengthFieldNumber = 5; + private readonly static ulong TotalLengthDefaultValue = 0UL; + + private ulong totalLength_; + /// + /// only populated for finite streams, if it's a stream of unknown size this stays empty + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ulong TotalLength { + get { if ((_hasBits0 & 2) != 0) { return totalLength_; } else { return TotalLengthDefaultValue; } } + set { + _hasBits0 |= 2; + totalLength_ = value; + } + } + /// Gets whether the "total_length" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasTotalLength { + get { return (_hasBits0 & 2) != 0; } + } + /// Clears the value of the "total_length" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearTotalLength() { + _hasBits0 &= ~2; + } + + /// Field number for the "attributes" field. + public const int AttributesFieldNumber = 6; + private static readonly pbc::MapField.Codec _map_attributes_codec + = new pbc::MapField.Codec(pb::FieldCodec.ForString(10, ""), pb::FieldCodec.ForString(18, ""), 50); + private readonly pbc::MapField attributes_ = new pbc::MapField(); + /// + /// user defined attributes map that can carry additional info + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::MapField Attributes { + get { return attributes_; } + } + + /// Field number for the "operation_type" field. + public const int OperationTypeFieldNumber = 7; + private readonly static global::LiveKit.Proto.TextStreamInfo.Types.OperationType OperationTypeDefaultValue = global::LiveKit.Proto.TextStreamInfo.Types.OperationType.Create; + + private global::LiveKit.Proto.TextStreamInfo.Types.OperationType operationType_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.TextStreamInfo.Types.OperationType OperationType { + get { if ((_hasBits0 & 4) != 0) { return operationType_; } else { return OperationTypeDefaultValue; } } + set { + _hasBits0 |= 4; + operationType_ = value; + } + } + /// Gets whether the "operation_type" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasOperationType { + get { return (_hasBits0 & 4) != 0; } + } + /// Clears the value of the "operation_type" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearOperationType() { + _hasBits0 &= ~4; + } + + /// Field number for the "version" field. + public const int VersionFieldNumber = 8; + private readonly static int VersionDefaultValue = 0; + + private int version_; + /// + /// Optional: Version for updates/edits + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int Version { + get { if ((_hasBits0 & 8) != 0) { return version_; } else { return VersionDefaultValue; } } + set { + _hasBits0 |= 8; + version_ = value; + } + } + /// Gets whether the "version" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasVersion { + get { return (_hasBits0 & 8) != 0; } + } + /// Clears the value of the "version" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearVersion() { + _hasBits0 &= ~8; + } + + /// Field number for the "reply_to_stream_id" field. + public const int ReplyToStreamIdFieldNumber = 9; + private readonly static string ReplyToStreamIdDefaultValue = ""; + + private string replyToStreamId_; + /// + /// Optional: Reply to specific message + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string ReplyToStreamId { + get { return replyToStreamId_ ?? ReplyToStreamIdDefaultValue; } + set { + replyToStreamId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + /// Gets whether the "reply_to_stream_id" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasReplyToStreamId { + get { return replyToStreamId_ != null; } + } + /// Clears the value of the "reply_to_stream_id" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearReplyToStreamId() { + replyToStreamId_ = null; + } + + /// Field number for the "attached_stream_ids" field. + public const int AttachedStreamIdsFieldNumber = 10; + private static readonly pb::FieldCodec _repeated_attachedStreamIds_codec + = pb::FieldCodec.ForString(82); + private readonly pbc::RepeatedField attachedStreamIds_ = new pbc::RepeatedField(); + /// + /// file attachments for text streams + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField AttachedStreamIds { + get { return attachedStreamIds_; } + } + + /// Field number for the "generated" field. + public const int GeneratedFieldNumber = 11; + private readonly static bool GeneratedDefaultValue = false; + + private bool generated_; + /// + /// true if the text has been generated by an agent from a participant's audio transcription + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Generated { + get { if ((_hasBits0 & 16) != 0) { return generated_; } else { return GeneratedDefaultValue; } } + set { + _hasBits0 |= 16; + generated_ = value; + } + } + /// Gets whether the "generated" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasGenerated { + get { return (_hasBits0 & 16) != 0; } + } + /// Clears the value of the "generated" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearGenerated() { + _hasBits0 &= ~16; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as TextStreamInfo); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(TextStreamInfo other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (StreamId != other.StreamId) return false; + if (Timestamp != other.Timestamp) return false; + if (MimeType != other.MimeType) return false; + if (Topic != other.Topic) return false; + if (TotalLength != other.TotalLength) return false; + if (!Attributes.Equals(other.Attributes)) return false; + if (OperationType != other.OperationType) return false; + if (Version != other.Version) return false; + if (ReplyToStreamId != other.ReplyToStreamId) return false; + if(!attachedStreamIds_.Equals(other.attachedStreamIds_)) return false; + if (Generated != other.Generated) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (HasStreamId) hash ^= StreamId.GetHashCode(); + if (HasTimestamp) hash ^= Timestamp.GetHashCode(); + if (HasMimeType) hash ^= MimeType.GetHashCode(); + if (HasTopic) hash ^= Topic.GetHashCode(); + if (HasTotalLength) hash ^= TotalLength.GetHashCode(); + hash ^= Attributes.GetHashCode(); + if (HasOperationType) hash ^= OperationType.GetHashCode(); + if (HasVersion) hash ^= Version.GetHashCode(); + if (HasReplyToStreamId) hash ^= ReplyToStreamId.GetHashCode(); + hash ^= attachedStreamIds_.GetHashCode(); + if (HasGenerated) hash ^= Generated.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (HasStreamId) { + output.WriteRawTag(10); + output.WriteString(StreamId); + } + if (HasTimestamp) { + output.WriteRawTag(16); + output.WriteInt64(Timestamp); + } + if (HasMimeType) { + output.WriteRawTag(26); + output.WriteString(MimeType); + } + if (HasTopic) { + output.WriteRawTag(34); + output.WriteString(Topic); + } + if (HasTotalLength) { + output.WriteRawTag(40); + output.WriteUInt64(TotalLength); + } + attributes_.WriteTo(output, _map_attributes_codec); + if (HasOperationType) { + output.WriteRawTag(56); + output.WriteEnum((int) OperationType); + } + if (HasVersion) { + output.WriteRawTag(64); + output.WriteInt32(Version); + } + if (HasReplyToStreamId) { + output.WriteRawTag(74); + output.WriteString(ReplyToStreamId); + } + attachedStreamIds_.WriteTo(output, _repeated_attachedStreamIds_codec); + if (HasGenerated) { + output.WriteRawTag(88); + output.WriteBool(Generated); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (HasStreamId) { + output.WriteRawTag(10); + output.WriteString(StreamId); + } + if (HasTimestamp) { + output.WriteRawTag(16); + output.WriteInt64(Timestamp); + } + if (HasMimeType) { + output.WriteRawTag(26); + output.WriteString(MimeType); + } + if (HasTopic) { + output.WriteRawTag(34); + output.WriteString(Topic); + } + if (HasTotalLength) { + output.WriteRawTag(40); + output.WriteUInt64(TotalLength); + } + attributes_.WriteTo(ref output, _map_attributes_codec); + if (HasOperationType) { + output.WriteRawTag(56); + output.WriteEnum((int) OperationType); + } + if (HasVersion) { + output.WriteRawTag(64); + output.WriteInt32(Version); + } + if (HasReplyToStreamId) { + output.WriteRawTag(74); + output.WriteString(ReplyToStreamId); + } + attachedStreamIds_.WriteTo(ref output, _repeated_attachedStreamIds_codec); + if (HasGenerated) { + output.WriteRawTag(88); + output.WriteBool(Generated); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (HasStreamId) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(StreamId); + } + if (HasTimestamp) { + size += 1 + pb::CodedOutputStream.ComputeInt64Size(Timestamp); + } + if (HasMimeType) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(MimeType); + } + if (HasTopic) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Topic); + } + if (HasTotalLength) { + size += 1 + pb::CodedOutputStream.ComputeUInt64Size(TotalLength); + } + size += attributes_.CalculateSize(_map_attributes_codec); + if (HasOperationType) { + size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) OperationType); + } + if (HasVersion) { + size += 1 + pb::CodedOutputStream.ComputeInt32Size(Version); + } + if (HasReplyToStreamId) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(ReplyToStreamId); + } + size += attachedStreamIds_.CalculateSize(_repeated_attachedStreamIds_codec); + if (HasGenerated) { + size += 1 + 1; + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(TextStreamInfo other) { + if (other == null) { + return; + } + if (other.HasStreamId) { + StreamId = other.StreamId; + } + if (other.HasTimestamp) { + Timestamp = other.Timestamp; + } + if (other.HasMimeType) { + MimeType = other.MimeType; + } + if (other.HasTopic) { + Topic = other.Topic; + } + if (other.HasTotalLength) { + TotalLength = other.TotalLength; + } + attributes_.MergeFrom(other.attributes_); + if (other.HasOperationType) { + OperationType = other.OperationType; + } + if (other.HasVersion) { + Version = other.Version; + } + if (other.HasReplyToStreamId) { + ReplyToStreamId = other.ReplyToStreamId; + } + attachedStreamIds_.Add(other.attachedStreamIds_); + if (other.HasGenerated) { + Generated = other.Generated; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + StreamId = input.ReadString(); + break; + } + case 16: { + Timestamp = input.ReadInt64(); + break; + } + case 26: { + MimeType = input.ReadString(); + break; + } + case 34: { + Topic = input.ReadString(); + break; + } + case 40: { + TotalLength = input.ReadUInt64(); + break; + } + case 50: { + attributes_.AddEntriesFrom(input, _map_attributes_codec); + break; + } + case 56: { + OperationType = (global::LiveKit.Proto.TextStreamInfo.Types.OperationType) input.ReadEnum(); + break; + } + case 64: { + Version = input.ReadInt32(); + break; + } + case 74: { + ReplyToStreamId = input.ReadString(); + break; + } + case 82: { + attachedStreamIds_.AddEntriesFrom(input, _repeated_attachedStreamIds_codec); + break; + } + case 88: { + Generated = input.ReadBool(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + StreamId = input.ReadString(); + break; + } + case 16: { + Timestamp = input.ReadInt64(); + break; + } + case 26: { + MimeType = input.ReadString(); + break; + } + case 34: { + Topic = input.ReadString(); + break; + } + case 40: { + TotalLength = input.ReadUInt64(); + break; + } + case 50: { + attributes_.AddEntriesFrom(ref input, _map_attributes_codec); + break; + } + case 56: { + OperationType = (global::LiveKit.Proto.TextStreamInfo.Types.OperationType) input.ReadEnum(); + break; + } + case 64: { + Version = input.ReadInt32(); + break; + } + case 74: { + ReplyToStreamId = input.ReadString(); + break; + } + case 82: { + attachedStreamIds_.AddEntriesFrom(ref input, _repeated_attachedStreamIds_codec); + break; + } + case 88: { + Generated = input.ReadBool(); + break; + } + } + } + } + #endif + + #region Nested types + /// Container for nested types declared in the TextStreamInfo message type. + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static partial class Types { + public enum OperationType { + [pbr::OriginalName("CREATE")] Create = 0, + [pbr::OriginalName("UPDATE")] Update = 1, + [pbr::OriginalName("DELETE")] Delete = 2, + [pbr::OriginalName("REACTION")] Reaction = 3, + } + + } + #endregion + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class ByteStreamInfo : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ByteStreamInfo()); + private pb::UnknownFieldSet _unknownFields; + private int _hasBits0; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.DataStreamReflection.Descriptor.MessageTypes[48]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ByteStreamInfo() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ByteStreamInfo(ByteStreamInfo other) : this() { + _hasBits0 = other._hasBits0; + streamId_ = other.streamId_; + timestamp_ = other.timestamp_; + mimeType_ = other.mimeType_; + topic_ = other.topic_; + totalLength_ = other.totalLength_; + attributes_ = other.attributes_.Clone(); + name_ = other.name_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ByteStreamInfo Clone() { + return new ByteStreamInfo(this); + } + + /// Field number for the "stream_id" field. + public const int StreamIdFieldNumber = 1; + private readonly static string StreamIdDefaultValue = ""; + + private string streamId_; + /// + /// unique identifier for this data stream + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string StreamId { + get { return streamId_ ?? StreamIdDefaultValue; } + set { + streamId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + /// Gets whether the "stream_id" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasStreamId { + get { return streamId_ != null; } + } + /// Clears the value of the "stream_id" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearStreamId() { + streamId_ = null; + } + + /// Field number for the "timestamp" field. + public const int TimestampFieldNumber = 2; + private readonly static long TimestampDefaultValue = 0L; + + private long timestamp_; + /// + /// using int64 for Unix timestamp + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public long Timestamp { + get { if ((_hasBits0 & 1) != 0) { return timestamp_; } else { return TimestampDefaultValue; } } + set { + _hasBits0 |= 1; + timestamp_ = value; + } + } + /// Gets whether the "timestamp" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasTimestamp { + get { return (_hasBits0 & 1) != 0; } + } + /// Clears the value of the "timestamp" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearTimestamp() { + _hasBits0 &= ~1; + } + + /// Field number for the "mime_type" field. + public const int MimeTypeFieldNumber = 3; + private readonly static string MimeTypeDefaultValue = ""; + + private string mimeType_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string MimeType { + get { return mimeType_ ?? MimeTypeDefaultValue; } + set { + mimeType_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + /// Gets whether the "mime_type" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasMimeType { + get { return mimeType_ != null; } + } + /// Clears the value of the "mime_type" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearMimeType() { + mimeType_ = null; + } + + /// Field number for the "topic" field. + public const int TopicFieldNumber = 4; + private readonly static string TopicDefaultValue = ""; + + private string topic_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Topic { + get { return topic_ ?? TopicDefaultValue; } + set { + topic_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + /// Gets whether the "topic" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasTopic { + get { return topic_ != null; } + } + /// Clears the value of the "topic" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearTopic() { + topic_ = null; + } + + /// Field number for the "total_length" field. + public const int TotalLengthFieldNumber = 5; + private readonly static ulong TotalLengthDefaultValue = 0UL; + + private ulong totalLength_; + /// + /// only populated for finite streams, if it's a stream of unknown size this stays empty + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ulong TotalLength { + get { if ((_hasBits0 & 2) != 0) { return totalLength_; } else { return TotalLengthDefaultValue; } } + set { + _hasBits0 |= 2; + totalLength_ = value; + } + } + /// Gets whether the "total_length" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasTotalLength { + get { return (_hasBits0 & 2) != 0; } + } + /// Clears the value of the "total_length" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearTotalLength() { + _hasBits0 &= ~2; + } + + /// Field number for the "attributes" field. + public const int AttributesFieldNumber = 6; + private static readonly pbc::MapField.Codec _map_attributes_codec + = new pbc::MapField.Codec(pb::FieldCodec.ForString(10, ""), pb::FieldCodec.ForString(18, ""), 50); + private readonly pbc::MapField attributes_ = new pbc::MapField(); + /// + /// user defined attributes map that can carry additional info + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::MapField Attributes { + get { return attributes_; } + } + + /// Field number for the "name" field. + public const int NameFieldNumber = 7; + private readonly static string NameDefaultValue = ""; + + private string name_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Name { + get { return name_ ?? NameDefaultValue; } + set { + name_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + /// Gets whether the "name" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasName { + get { return name_ != null; } + } + /// Clears the value of the "name" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearName() { + name_ = null; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as ByteStreamInfo); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(ByteStreamInfo other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (StreamId != other.StreamId) return false; + if (Timestamp != other.Timestamp) return false; + if (MimeType != other.MimeType) return false; + if (Topic != other.Topic) return false; + if (TotalLength != other.TotalLength) return false; + if (!Attributes.Equals(other.Attributes)) return false; + if (Name != other.Name) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (HasStreamId) hash ^= StreamId.GetHashCode(); + if (HasTimestamp) hash ^= Timestamp.GetHashCode(); + if (HasMimeType) hash ^= MimeType.GetHashCode(); + if (HasTopic) hash ^= Topic.GetHashCode(); + if (HasTotalLength) hash ^= TotalLength.GetHashCode(); + hash ^= Attributes.GetHashCode(); + if (HasName) hash ^= Name.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (HasStreamId) { + output.WriteRawTag(10); + output.WriteString(StreamId); + } + if (HasTimestamp) { + output.WriteRawTag(16); + output.WriteInt64(Timestamp); + } + if (HasMimeType) { + output.WriteRawTag(26); + output.WriteString(MimeType); + } + if (HasTopic) { + output.WriteRawTag(34); + output.WriteString(Topic); + } + if (HasTotalLength) { + output.WriteRawTag(40); + output.WriteUInt64(TotalLength); + } + attributes_.WriteTo(output, _map_attributes_codec); + if (HasName) { + output.WriteRawTag(58); + output.WriteString(Name); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (HasStreamId) { + output.WriteRawTag(10); + output.WriteString(StreamId); + } + if (HasTimestamp) { + output.WriteRawTag(16); + output.WriteInt64(Timestamp); + } + if (HasMimeType) { + output.WriteRawTag(26); + output.WriteString(MimeType); + } + if (HasTopic) { + output.WriteRawTag(34); + output.WriteString(Topic); + } + if (HasTotalLength) { + output.WriteRawTag(40); + output.WriteUInt64(TotalLength); + } + attributes_.WriteTo(ref output, _map_attributes_codec); + if (HasName) { + output.WriteRawTag(58); + output.WriteString(Name); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (HasStreamId) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(StreamId); + } + if (HasTimestamp) { + size += 1 + pb::CodedOutputStream.ComputeInt64Size(Timestamp); + } + if (HasMimeType) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(MimeType); + } + if (HasTopic) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Topic); + } + if (HasTotalLength) { + size += 1 + pb::CodedOutputStream.ComputeUInt64Size(TotalLength); + } + size += attributes_.CalculateSize(_map_attributes_codec); + if (HasName) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Name); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(ByteStreamInfo other) { + if (other == null) { + return; + } + if (other.HasStreamId) { + StreamId = other.StreamId; + } + if (other.HasTimestamp) { + Timestamp = other.Timestamp; + } + if (other.HasMimeType) { + MimeType = other.MimeType; + } + if (other.HasTopic) { + Topic = other.Topic; + } + if (other.HasTotalLength) { + TotalLength = other.TotalLength; + } + attributes_.MergeFrom(other.attributes_); + if (other.HasName) { + Name = other.Name; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + StreamId = input.ReadString(); + break; + } + case 16: { + Timestamp = input.ReadInt64(); + break; + } + case 26: { + MimeType = input.ReadString(); + break; + } + case 34: { + Topic = input.ReadString(); + break; + } + case 40: { + TotalLength = input.ReadUInt64(); + break; + } + case 50: { + attributes_.AddEntriesFrom(input, _map_attributes_codec); + break; + } + case 58: { + Name = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + StreamId = input.ReadString(); + break; + } + case 16: { + Timestamp = input.ReadInt64(); + break; + } + case 26: { + MimeType = input.ReadString(); + break; + } + case 34: { + Topic = input.ReadString(); + break; + } + case 40: { + TotalLength = input.ReadUInt64(); + break; + } + case 50: { + attributes_.AddEntriesFrom(ref input, _map_attributes_codec); + break; + } + case 58: { + Name = input.ReadString(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class StreamTextOptions : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new StreamTextOptions()); + private pb::UnknownFieldSet _unknownFields; + private int _hasBits0; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.DataStreamReflection.Descriptor.MessageTypes[49]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public StreamTextOptions() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public StreamTextOptions(StreamTextOptions other) : this() { + _hasBits0 = other._hasBits0; + topic_ = other.topic_; + attributes_ = other.attributes_.Clone(); + destinationIdentities_ = other.destinationIdentities_.Clone(); + id_ = other.id_; + operationType_ = other.operationType_; + version_ = other.version_; + replyToStreamId_ = other.replyToStreamId_; + attachedStreamIds_ = other.attachedStreamIds_.Clone(); + generated_ = other.generated_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public StreamTextOptions Clone() { + return new StreamTextOptions(this); + } + + /// Field number for the "topic" field. + public const int TopicFieldNumber = 1; + private readonly static string TopicDefaultValue = ""; + + private string topic_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Topic { + get { return topic_ ?? TopicDefaultValue; } + set { + topic_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + /// Gets whether the "topic" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasTopic { + get { return topic_ != null; } + } + /// Clears the value of the "topic" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearTopic() { + topic_ = null; + } + + /// Field number for the "attributes" field. + public const int AttributesFieldNumber = 2; + private static readonly pbc::MapField.Codec _map_attributes_codec + = new pbc::MapField.Codec(pb::FieldCodec.ForString(10, ""), pb::FieldCodec.ForString(18, ""), 18); + private readonly pbc::MapField attributes_ = new pbc::MapField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::MapField Attributes { + get { return attributes_; } + } + + /// Field number for the "destination_identities" field. + public const int DestinationIdentitiesFieldNumber = 3; + private static readonly pb::FieldCodec _repeated_destinationIdentities_codec + = pb::FieldCodec.ForString(26); + private readonly pbc::RepeatedField destinationIdentities_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField DestinationIdentities { + get { return destinationIdentities_; } + } + + /// Field number for the "id" field. + public const int IdFieldNumber = 4; + private readonly static string IdDefaultValue = ""; + + private string id_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Id { + get { return id_ ?? IdDefaultValue; } + set { + id_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + /// Gets whether the "id" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasId { + get { return id_ != null; } + } + /// Clears the value of the "id" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearId() { + id_ = null; + } + + /// Field number for the "operation_type" field. + public const int OperationTypeFieldNumber = 5; + private readonly static global::LiveKit.Proto.TextStreamInfo.Types.OperationType OperationTypeDefaultValue = global::LiveKit.Proto.TextStreamInfo.Types.OperationType.Create; + + private global::LiveKit.Proto.TextStreamInfo.Types.OperationType operationType_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.TextStreamInfo.Types.OperationType OperationType { + get { if ((_hasBits0 & 1) != 0) { return operationType_; } else { return OperationTypeDefaultValue; } } + set { + _hasBits0 |= 1; + operationType_ = value; + } + } + /// Gets whether the "operation_type" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasOperationType { + get { return (_hasBits0 & 1) != 0; } + } + /// Clears the value of the "operation_type" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearOperationType() { + _hasBits0 &= ~1; + } + + /// Field number for the "version" field. + public const int VersionFieldNumber = 6; + private readonly static int VersionDefaultValue = 0; + + private int version_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int Version { + get { if ((_hasBits0 & 2) != 0) { return version_; } else { return VersionDefaultValue; } } + set { + _hasBits0 |= 2; + version_ = value; + } + } + /// Gets whether the "version" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasVersion { + get { return (_hasBits0 & 2) != 0; } + } + /// Clears the value of the "version" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearVersion() { + _hasBits0 &= ~2; + } + + /// Field number for the "reply_to_stream_id" field. + public const int ReplyToStreamIdFieldNumber = 7; + private readonly static string ReplyToStreamIdDefaultValue = ""; + + private string replyToStreamId_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string ReplyToStreamId { + get { return replyToStreamId_ ?? ReplyToStreamIdDefaultValue; } + set { + replyToStreamId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + /// Gets whether the "reply_to_stream_id" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasReplyToStreamId { + get { return replyToStreamId_ != null; } + } + /// Clears the value of the "reply_to_stream_id" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearReplyToStreamId() { + replyToStreamId_ = null; + } + + /// Field number for the "attached_stream_ids" field. + public const int AttachedStreamIdsFieldNumber = 8; + private static readonly pb::FieldCodec _repeated_attachedStreamIds_codec + = pb::FieldCodec.ForString(66); + private readonly pbc::RepeatedField attachedStreamIds_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField AttachedStreamIds { + get { return attachedStreamIds_; } + } + + /// Field number for the "generated" field. + public const int GeneratedFieldNumber = 9; + private readonly static bool GeneratedDefaultValue = false; + + private bool generated_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Generated { + get { if ((_hasBits0 & 4) != 0) { return generated_; } else { return GeneratedDefaultValue; } } + set { + _hasBits0 |= 4; + generated_ = value; + } + } + /// Gets whether the "generated" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasGenerated { + get { return (_hasBits0 & 4) != 0; } + } + /// Clears the value of the "generated" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearGenerated() { + _hasBits0 &= ~4; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as StreamTextOptions); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(StreamTextOptions other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Topic != other.Topic) return false; + if (!Attributes.Equals(other.Attributes)) return false; + if(!destinationIdentities_.Equals(other.destinationIdentities_)) return false; + if (Id != other.Id) return false; + if (OperationType != other.OperationType) return false; + if (Version != other.Version) return false; + if (ReplyToStreamId != other.ReplyToStreamId) return false; + if(!attachedStreamIds_.Equals(other.attachedStreamIds_)) return false; + if (Generated != other.Generated) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (HasTopic) hash ^= Topic.GetHashCode(); + hash ^= Attributes.GetHashCode(); + hash ^= destinationIdentities_.GetHashCode(); + if (HasId) hash ^= Id.GetHashCode(); + if (HasOperationType) hash ^= OperationType.GetHashCode(); + if (HasVersion) hash ^= Version.GetHashCode(); + if (HasReplyToStreamId) hash ^= ReplyToStreamId.GetHashCode(); + hash ^= attachedStreamIds_.GetHashCode(); + if (HasGenerated) hash ^= Generated.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (HasTopic) { + output.WriteRawTag(10); + output.WriteString(Topic); + } + attributes_.WriteTo(output, _map_attributes_codec); + destinationIdentities_.WriteTo(output, _repeated_destinationIdentities_codec); + if (HasId) { + output.WriteRawTag(34); + output.WriteString(Id); + } + if (HasOperationType) { + output.WriteRawTag(40); + output.WriteEnum((int) OperationType); + } + if (HasVersion) { + output.WriteRawTag(48); + output.WriteInt32(Version); + } + if (HasReplyToStreamId) { + output.WriteRawTag(58); + output.WriteString(ReplyToStreamId); + } + attachedStreamIds_.WriteTo(output, _repeated_attachedStreamIds_codec); + if (HasGenerated) { + output.WriteRawTag(72); + output.WriteBool(Generated); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (HasTopic) { + output.WriteRawTag(10); + output.WriteString(Topic); + } + attributes_.WriteTo(ref output, _map_attributes_codec); + destinationIdentities_.WriteTo(ref output, _repeated_destinationIdentities_codec); + if (HasId) { + output.WriteRawTag(34); + output.WriteString(Id); + } + if (HasOperationType) { + output.WriteRawTag(40); + output.WriteEnum((int) OperationType); + } + if (HasVersion) { + output.WriteRawTag(48); + output.WriteInt32(Version); + } + if (HasReplyToStreamId) { + output.WriteRawTag(58); + output.WriteString(ReplyToStreamId); + } + attachedStreamIds_.WriteTo(ref output, _repeated_attachedStreamIds_codec); + if (HasGenerated) { + output.WriteRawTag(72); + output.WriteBool(Generated); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (HasTopic) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Topic); + } + size += attributes_.CalculateSize(_map_attributes_codec); + size += destinationIdentities_.CalculateSize(_repeated_destinationIdentities_codec); + if (HasId) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Id); + } + if (HasOperationType) { + size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) OperationType); + } + if (HasVersion) { + size += 1 + pb::CodedOutputStream.ComputeInt32Size(Version); + } + if (HasReplyToStreamId) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(ReplyToStreamId); + } + size += attachedStreamIds_.CalculateSize(_repeated_attachedStreamIds_codec); + if (HasGenerated) { + size += 1 + 1; + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(StreamTextOptions other) { + if (other == null) { + return; + } + if (other.HasTopic) { + Topic = other.Topic; + } + attributes_.MergeFrom(other.attributes_); + destinationIdentities_.Add(other.destinationIdentities_); + if (other.HasId) { + Id = other.Id; + } + if (other.HasOperationType) { + OperationType = other.OperationType; + } + if (other.HasVersion) { + Version = other.Version; + } + if (other.HasReplyToStreamId) { + ReplyToStreamId = other.ReplyToStreamId; + } + attachedStreamIds_.Add(other.attachedStreamIds_); + if (other.HasGenerated) { + Generated = other.Generated; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + Topic = input.ReadString(); + break; + } + case 18: { + attributes_.AddEntriesFrom(input, _map_attributes_codec); + break; + } + case 26: { + destinationIdentities_.AddEntriesFrom(input, _repeated_destinationIdentities_codec); + break; + } + case 34: { + Id = input.ReadString(); + break; + } + case 40: { + OperationType = (global::LiveKit.Proto.TextStreamInfo.Types.OperationType) input.ReadEnum(); + break; + } + case 48: { + Version = input.ReadInt32(); + break; + } + case 58: { + ReplyToStreamId = input.ReadString(); + break; + } + case 66: { + attachedStreamIds_.AddEntriesFrom(input, _repeated_attachedStreamIds_codec); + break; + } + case 72: { + Generated = input.ReadBool(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + Topic = input.ReadString(); + break; + } + case 18: { + attributes_.AddEntriesFrom(ref input, _map_attributes_codec); + break; + } + case 26: { + destinationIdentities_.AddEntriesFrom(ref input, _repeated_destinationIdentities_codec); + break; + } + case 34: { + Id = input.ReadString(); + break; + } + case 40: { + OperationType = (global::LiveKit.Proto.TextStreamInfo.Types.OperationType) input.ReadEnum(); + break; + } + case 48: { + Version = input.ReadInt32(); + break; + } + case 58: { + ReplyToStreamId = input.ReadString(); + break; + } + case 66: { + attachedStreamIds_.AddEntriesFrom(ref input, _repeated_attachedStreamIds_codec); + break; + } + case 72: { + Generated = input.ReadBool(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class StreamByteOptions : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new StreamByteOptions()); + private pb::UnknownFieldSet _unknownFields; + private int _hasBits0; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.DataStreamReflection.Descriptor.MessageTypes[50]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public StreamByteOptions() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public StreamByteOptions(StreamByteOptions other) : this() { + _hasBits0 = other._hasBits0; + topic_ = other.topic_; + attributes_ = other.attributes_.Clone(); + destinationIdentities_ = other.destinationIdentities_.Clone(); + id_ = other.id_; + name_ = other.name_; + mimeType_ = other.mimeType_; + totalLength_ = other.totalLength_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public StreamByteOptions Clone() { + return new StreamByteOptions(this); + } + + /// Field number for the "topic" field. + public const int TopicFieldNumber = 1; + private readonly static string TopicDefaultValue = ""; + + private string topic_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Topic { + get { return topic_ ?? TopicDefaultValue; } + set { + topic_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + /// Gets whether the "topic" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasTopic { + get { return topic_ != null; } + } + /// Clears the value of the "topic" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearTopic() { + topic_ = null; + } + + /// Field number for the "attributes" field. + public const int AttributesFieldNumber = 2; + private static readonly pbc::MapField.Codec _map_attributes_codec + = new pbc::MapField.Codec(pb::FieldCodec.ForString(10, ""), pb::FieldCodec.ForString(18, ""), 18); + private readonly pbc::MapField attributes_ = new pbc::MapField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::MapField Attributes { + get { return attributes_; } + } + + /// Field number for the "destination_identities" field. + public const int DestinationIdentitiesFieldNumber = 3; + private static readonly pb::FieldCodec _repeated_destinationIdentities_codec + = pb::FieldCodec.ForString(26); + private readonly pbc::RepeatedField destinationIdentities_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField DestinationIdentities { + get { return destinationIdentities_; } + } + + /// Field number for the "id" field. + public const int IdFieldNumber = 4; + private readonly static string IdDefaultValue = ""; + + private string id_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Id { + get { return id_ ?? IdDefaultValue; } + set { + id_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + /// Gets whether the "id" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasId { + get { return id_ != null; } + } + /// Clears the value of the "id" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearId() { + id_ = null; + } + + /// Field number for the "name" field. + public const int NameFieldNumber = 5; + private readonly static string NameDefaultValue = ""; + + private string name_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Name { + get { return name_ ?? NameDefaultValue; } + set { + name_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + /// Gets whether the "name" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasName { + get { return name_ != null; } + } + /// Clears the value of the "name" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearName() { + name_ = null; + } + + /// Field number for the "mime_type" field. + public const int MimeTypeFieldNumber = 6; + private readonly static string MimeTypeDefaultValue = ""; + + private string mimeType_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string MimeType { + get { return mimeType_ ?? MimeTypeDefaultValue; } + set { + mimeType_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + /// Gets whether the "mime_type" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasMimeType { + get { return mimeType_ != null; } + } + /// Clears the value of the "mime_type" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearMimeType() { + mimeType_ = null; + } + + /// Field number for the "total_length" field. + public const int TotalLengthFieldNumber = 7; + private readonly static ulong TotalLengthDefaultValue = 0UL; + + private ulong totalLength_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ulong TotalLength { + get { if ((_hasBits0 & 1) != 0) { return totalLength_; } else { return TotalLengthDefaultValue; } } + set { + _hasBits0 |= 1; + totalLength_ = value; + } + } + /// Gets whether the "total_length" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasTotalLength { + get { return (_hasBits0 & 1) != 0; } + } + /// Clears the value of the "total_length" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearTotalLength() { + _hasBits0 &= ~1; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as StreamByteOptions); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(StreamByteOptions other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Topic != other.Topic) return false; + if (!Attributes.Equals(other.Attributes)) return false; + if(!destinationIdentities_.Equals(other.destinationIdentities_)) return false; + if (Id != other.Id) return false; + if (Name != other.Name) return false; + if (MimeType != other.MimeType) return false; + if (TotalLength != other.TotalLength) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (HasTopic) hash ^= Topic.GetHashCode(); + hash ^= Attributes.GetHashCode(); + hash ^= destinationIdentities_.GetHashCode(); + if (HasId) hash ^= Id.GetHashCode(); + if (HasName) hash ^= Name.GetHashCode(); + if (HasMimeType) hash ^= MimeType.GetHashCode(); + if (HasTotalLength) hash ^= TotalLength.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (HasTopic) { + output.WriteRawTag(10); + output.WriteString(Topic); + } + attributes_.WriteTo(output, _map_attributes_codec); + destinationIdentities_.WriteTo(output, _repeated_destinationIdentities_codec); + if (HasId) { + output.WriteRawTag(34); + output.WriteString(Id); + } + if (HasName) { + output.WriteRawTag(42); + output.WriteString(Name); + } + if (HasMimeType) { + output.WriteRawTag(50); + output.WriteString(MimeType); + } + if (HasTotalLength) { + output.WriteRawTag(56); + output.WriteUInt64(TotalLength); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (HasTopic) { + output.WriteRawTag(10); + output.WriteString(Topic); + } + attributes_.WriteTo(ref output, _map_attributes_codec); + destinationIdentities_.WriteTo(ref output, _repeated_destinationIdentities_codec); + if (HasId) { + output.WriteRawTag(34); + output.WriteString(Id); + } + if (HasName) { + output.WriteRawTag(42); + output.WriteString(Name); + } + if (HasMimeType) { + output.WriteRawTag(50); + output.WriteString(MimeType); + } + if (HasTotalLength) { + output.WriteRawTag(56); + output.WriteUInt64(TotalLength); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (HasTopic) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Topic); + } + size += attributes_.CalculateSize(_map_attributes_codec); + size += destinationIdentities_.CalculateSize(_repeated_destinationIdentities_codec); + if (HasId) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Id); + } + if (HasName) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Name); + } + if (HasMimeType) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(MimeType); + } + if (HasTotalLength) { + size += 1 + pb::CodedOutputStream.ComputeUInt64Size(TotalLength); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(StreamByteOptions other) { + if (other == null) { + return; + } + if (other.HasTopic) { + Topic = other.Topic; + } + attributes_.MergeFrom(other.attributes_); + destinationIdentities_.Add(other.destinationIdentities_); + if (other.HasId) { + Id = other.Id; + } + if (other.HasName) { + Name = other.Name; + } + if (other.HasMimeType) { + MimeType = other.MimeType; + } + if (other.HasTotalLength) { + TotalLength = other.TotalLength; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + Topic = input.ReadString(); + break; + } + case 18: { + attributes_.AddEntriesFrom(input, _map_attributes_codec); + break; + } + case 26: { + destinationIdentities_.AddEntriesFrom(input, _repeated_destinationIdentities_codec); + break; + } + case 34: { + Id = input.ReadString(); + break; + } + case 42: { + Name = input.ReadString(); + break; + } + case 50: { + MimeType = input.ReadString(); + break; + } + case 56: { + TotalLength = input.ReadUInt64(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + Topic = input.ReadString(); + break; + } + case 18: { + attributes_.AddEntriesFrom(ref input, _map_attributes_codec); + break; + } + case 26: { + destinationIdentities_.AddEntriesFrom(ref input, _repeated_destinationIdentities_codec); + break; + } + case 34: { + Id = input.ReadString(); + break; + } + case 42: { + Name = input.ReadString(); + break; + } + case 50: { + MimeType = input.ReadString(); + break; + } + case 56: { + TotalLength = input.ReadUInt64(); + break; + } + } + } + } + #endif + + } + + /// + /// Error pertaining to a stream. + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class StreamError : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new StreamError()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.DataStreamReflection.Descriptor.MessageTypes[51]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public StreamError() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public StreamError(StreamError other) : this() { + description_ = other.description_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public StreamError Clone() { + return new StreamError(this); + } + + /// Field number for the "description" field. + public const int DescriptionFieldNumber = 1; + private readonly static string DescriptionDefaultValue = ""; + + private string description_; + /// + /// TODO(ladvoc): make this an enum. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Description { + get { return description_ ?? DescriptionDefaultValue; } + set { + description_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + /// Gets whether the "description" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasDescription { + get { return description_ != null; } + } + /// Clears the value of the "description" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearDescription() { + description_ = null; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as StreamError); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(StreamError other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Description != other.Description) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (HasDescription) hash ^= Description.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (HasDescription) { + output.WriteRawTag(10); + output.WriteString(Description); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (HasDescription) { + output.WriteRawTag(10); + output.WriteString(Description); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (HasDescription) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Description); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(StreamError other) { + if (other == null) { + return; + } + if (other.HasDescription) { + Description = other.Description; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + Description = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + Description = input.ReadString(); + break; + } + } + } + } + #endif + + } + + #endregion + +} + +#endregion Designer generated code diff --git a/Runtime/Scripts/Proto/DataStream.cs.meta b/Runtime/Scripts/Proto/DataStream.cs.meta new file mode 100644 index 00000000..24b0c47c --- /dev/null +++ b/Runtime/Scripts/Proto/DataStream.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: bd9e8ea10848e409d98509798bb04819 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Runtime/Scripts/Proto/Ffi.cs b/Runtime/Scripts/Proto/Ffi.cs index 9a5cb53d..34d80549 100644 --- a/Runtime/Scripts/Proto/Ffi.cs +++ b/Runtime/Scripts/Proto/Ffi.cs @@ -25,176 +25,291 @@ static FfiReflection() { byte[] descriptorData = global::System.Convert.FromBase64String( string.Concat( "CglmZmkucHJvdG8SDWxpdmVraXQucHJvdG8aCmUyZWUucHJvdG8aC3RyYWNr", - "LnByb3RvGgpyb29tLnByb3RvGhF2aWRlb19mcmFtZS5wcm90bxoRYXVkaW9f", - "ZnJhbWUucHJvdG8aCXJwYy5wcm90byKmFQoKRmZpUmVxdWVzdBIwCgdkaXNw", - "b3NlGAIgASgLMh0ubGl2ZWtpdC5wcm90by5EaXNwb3NlUmVxdWVzdEgAEjAK", - "B2Nvbm5lY3QYAyABKAsyHS5saXZla2l0LnByb3RvLkNvbm5lY3RSZXF1ZXN0", - "SAASNgoKZGlzY29ubmVjdBgEIAEoCzIgLmxpdmVraXQucHJvdG8uRGlzY29u", - "bmVjdFJlcXVlc3RIABI7Cg1wdWJsaXNoX3RyYWNrGAUgASgLMiIubGl2ZWtp", - "dC5wcm90by5QdWJsaXNoVHJhY2tSZXF1ZXN0SAASPwoPdW5wdWJsaXNoX3Ry", - "YWNrGAYgASgLMiQubGl2ZWtpdC5wcm90by5VbnB1Ymxpc2hUcmFja1JlcXVl", - "c3RIABI5CgxwdWJsaXNoX2RhdGEYByABKAsyIS5saXZla2l0LnByb3RvLlB1", - "Ymxpc2hEYXRhUmVxdWVzdEgAEj0KDnNldF9zdWJzY3JpYmVkGAggASgLMiMu", - "bGl2ZWtpdC5wcm90by5TZXRTdWJzY3JpYmVkUmVxdWVzdEgAEkQKEnNldF9s", - "b2NhbF9tZXRhZGF0YRgJIAEoCzImLmxpdmVraXQucHJvdG8uU2V0TG9jYWxN", - "ZXRhZGF0YVJlcXVlc3RIABI8Cg5zZXRfbG9jYWxfbmFtZRgKIAEoCzIiLmxp", - "dmVraXQucHJvdG8uU2V0TG9jYWxOYW1lUmVxdWVzdEgAEkgKFHNldF9sb2Nh", - "bF9hdHRyaWJ1dGVzGAsgASgLMigubGl2ZWtpdC5wcm90by5TZXRMb2NhbEF0", - "dHJpYnV0ZXNSZXF1ZXN0SAASQgoRZ2V0X3Nlc3Npb25fc3RhdHMYDCABKAsy", - "JS5saXZla2l0LnByb3RvLkdldFNlc3Npb25TdGF0c1JlcXVlc3RIABJLChVw", - "dWJsaXNoX3RyYW5zY3JpcHRpb24YDSABKAsyKi5saXZla2l0LnByb3RvLlB1", - "Ymxpc2hUcmFuc2NyaXB0aW9uUmVxdWVzdEgAEkAKEHB1Ymxpc2hfc2lwX2R0", - "bWYYDiABKAsyJC5saXZla2l0LnByb3RvLlB1Ymxpc2hTaXBEdG1mUmVxdWVz", - "dEgAEkQKEmNyZWF0ZV92aWRlb190cmFjaxgPIAEoCzImLmxpdmVraXQucHJv", - "dG8uQ3JlYXRlVmlkZW9UcmFja1JlcXVlc3RIABJEChJjcmVhdGVfYXVkaW9f", - "dHJhY2sYECABKAsyJi5saXZla2l0LnByb3RvLkNyZWF0ZUF1ZGlvVHJhY2tS", - "ZXF1ZXN0SAASQAoQbG9jYWxfdHJhY2tfbXV0ZRgRIAEoCzIkLmxpdmVraXQu", - "cHJvdG8uTG9jYWxUcmFja011dGVSZXF1ZXN0SAASRgoTZW5hYmxlX3JlbW90", - "ZV90cmFjaxgSIAEoCzInLmxpdmVraXQucHJvdG8uRW5hYmxlUmVtb3RlVHJh", - "Y2tSZXF1ZXN0SAASMwoJZ2V0X3N0YXRzGBMgASgLMh4ubGl2ZWtpdC5wcm90", - "by5HZXRTdGF0c1JlcXVlc3RIABJAChBuZXdfdmlkZW9fc3RyZWFtGBQgASgL", - "MiQubGl2ZWtpdC5wcm90by5OZXdWaWRlb1N0cmVhbVJlcXVlc3RIABJAChBu", - "ZXdfdmlkZW9fc291cmNlGBUgASgLMiQubGl2ZWtpdC5wcm90by5OZXdWaWRl", - "b1NvdXJjZVJlcXVlc3RIABJGChNjYXB0dXJlX3ZpZGVvX2ZyYW1lGBYgASgL", - "MicubGl2ZWtpdC5wcm90by5DYXB0dXJlVmlkZW9GcmFtZVJlcXVlc3RIABI7", - "Cg12aWRlb19jb252ZXJ0GBcgASgLMiIubGl2ZWtpdC5wcm90by5WaWRlb0Nv", - "bnZlcnRSZXF1ZXN0SAASWQoddmlkZW9fc3RyZWFtX2Zyb21fcGFydGljaXBh", - "bnQYGCABKAsyMC5saXZla2l0LnByb3RvLlZpZGVvU3RyZWFtRnJvbVBhcnRp", - "Y2lwYW50UmVxdWVzdEgAEkAKEG5ld19hdWRpb19zdHJlYW0YGSABKAsyJC5s", - "aXZla2l0LnByb3RvLk5ld0F1ZGlvU3RyZWFtUmVxdWVzdEgAEkAKEG5ld19h", - "dWRpb19zb3VyY2UYGiABKAsyJC5saXZla2l0LnByb3RvLk5ld0F1ZGlvU291", - "cmNlUmVxdWVzdEgAEkYKE2NhcHR1cmVfYXVkaW9fZnJhbWUYGyABKAsyJy5s", - "aXZla2l0LnByb3RvLkNhcHR1cmVBdWRpb0ZyYW1lUmVxdWVzdEgAEkQKEmNs", - "ZWFyX2F1ZGlvX2J1ZmZlchgcIAEoCzImLmxpdmVraXQucHJvdG8uQ2xlYXJB", - "dWRpb0J1ZmZlclJlcXVlc3RIABJGChNuZXdfYXVkaW9fcmVzYW1wbGVyGB0g", - "ASgLMicubGl2ZWtpdC5wcm90by5OZXdBdWRpb1Jlc2FtcGxlclJlcXVlc3RI", - "ABJEChJyZW1peF9hbmRfcmVzYW1wbGUYHiABKAsyJi5saXZla2l0LnByb3Rv", - "LlJlbWl4QW5kUmVzYW1wbGVSZXF1ZXN0SAASKgoEZTJlZRgfIAEoCzIaLmxp", - "dmVraXQucHJvdG8uRTJlZVJlcXVlc3RIABJZCh1hdWRpb19zdHJlYW1fZnJv", - "bV9wYXJ0aWNpcGFudBggIAEoCzIwLmxpdmVraXQucHJvdG8uQXVkaW9TdHJl", - "YW1Gcm9tUGFydGljaXBhbnRSZXF1ZXN0SAASQgoRbmV3X3NveF9yZXNhbXBs", - "ZXIYISABKAsyJS5saXZla2l0LnByb3RvLk5ld1NveFJlc2FtcGxlclJlcXVl", - "c3RIABJEChJwdXNoX3NveF9yZXNhbXBsZXIYIiABKAsyJi5saXZla2l0LnBy", - "b3RvLlB1c2hTb3hSZXNhbXBsZXJSZXF1ZXN0SAASRgoTZmx1c2hfc294X3Jl", - "c2FtcGxlchgjIAEoCzInLmxpdmVraXQucHJvdG8uRmx1c2hTb3hSZXNhbXBs", - "ZXJSZXF1ZXN0SAASQgoRc2VuZF9jaGF0X21lc3NhZ2UYJCABKAsyJS5saXZl", - "a2l0LnByb3RvLlNlbmRDaGF0TWVzc2FnZVJlcXVlc3RIABJCChFlZGl0X2No", - "YXRfbWVzc2FnZRglIAEoCzIlLmxpdmVraXQucHJvdG8uRWRpdENoYXRNZXNz", - "YWdlUmVxdWVzdEgAEjcKC3BlcmZvcm1fcnBjGCYgASgLMiAubGl2ZWtpdC5w", - "cm90by5QZXJmb3JtUnBjUmVxdWVzdEgAEkYKE3JlZ2lzdGVyX3JwY19tZXRo", - "b2QYJyABKAsyJy5saXZla2l0LnByb3RvLlJlZ2lzdGVyUnBjTWV0aG9kUmVx", - "dWVzdEgAEkoKFXVucmVnaXN0ZXJfcnBjX21ldGhvZBgoIAEoCzIpLmxpdmVr", - "aXQucHJvdG8uVW5yZWdpc3RlclJwY01ldGhvZFJlcXVlc3RIABJbCh5ycGNf", - "bWV0aG9kX2ludm9jYXRpb25fcmVzcG9uc2UYKSABKAsyMS5saXZla2l0LnBy", - "b3RvLlJwY01ldGhvZEludm9jYXRpb25SZXNwb25zZVJlcXVlc3RIAEIJCgdt", - "ZXNzYWdlIooVCgtGZmlSZXNwb25zZRIxCgdkaXNwb3NlGAIgASgLMh4ubGl2", - "ZWtpdC5wcm90by5EaXNwb3NlUmVzcG9uc2VIABIxCgdjb25uZWN0GAMgASgL", - "Mh4ubGl2ZWtpdC5wcm90by5Db25uZWN0UmVzcG9uc2VIABI3CgpkaXNjb25u", - "ZWN0GAQgASgLMiEubGl2ZWtpdC5wcm90by5EaXNjb25uZWN0UmVzcG9uc2VI", - "ABI8Cg1wdWJsaXNoX3RyYWNrGAUgASgLMiMubGl2ZWtpdC5wcm90by5QdWJs", - "aXNoVHJhY2tSZXNwb25zZUgAEkAKD3VucHVibGlzaF90cmFjaxgGIAEoCzIl", - "LmxpdmVraXQucHJvdG8uVW5wdWJsaXNoVHJhY2tSZXNwb25zZUgAEjoKDHB1", - "Ymxpc2hfZGF0YRgHIAEoCzIiLmxpdmVraXQucHJvdG8uUHVibGlzaERhdGFS", - "ZXNwb25zZUgAEj4KDnNldF9zdWJzY3JpYmVkGAggASgLMiQubGl2ZWtpdC5w", - "cm90by5TZXRTdWJzY3JpYmVkUmVzcG9uc2VIABJFChJzZXRfbG9jYWxfbWV0", - "YWRhdGEYCSABKAsyJy5saXZla2l0LnByb3RvLlNldExvY2FsTWV0YWRhdGFS", - "ZXNwb25zZUgAEj0KDnNldF9sb2NhbF9uYW1lGAogASgLMiMubGl2ZWtpdC5w", - "cm90by5TZXRMb2NhbE5hbWVSZXNwb25zZUgAEkkKFHNldF9sb2NhbF9hdHRy", - "aWJ1dGVzGAsgASgLMikubGl2ZWtpdC5wcm90by5TZXRMb2NhbEF0dHJpYnV0", - "ZXNSZXNwb25zZUgAEkMKEWdldF9zZXNzaW9uX3N0YXRzGAwgASgLMiYubGl2", - "ZWtpdC5wcm90by5HZXRTZXNzaW9uU3RhdHNSZXNwb25zZUgAEkwKFXB1Ymxp", - "c2hfdHJhbnNjcmlwdGlvbhgNIAEoCzIrLmxpdmVraXQucHJvdG8uUHVibGlz", - "aFRyYW5zY3JpcHRpb25SZXNwb25zZUgAEkEKEHB1Ymxpc2hfc2lwX2R0bWYY", - "DiABKAsyJS5saXZla2l0LnByb3RvLlB1Ymxpc2hTaXBEdG1mUmVzcG9uc2VI", - "ABJFChJjcmVhdGVfdmlkZW9fdHJhY2sYDyABKAsyJy5saXZla2l0LnByb3Rv", - "LkNyZWF0ZVZpZGVvVHJhY2tSZXNwb25zZUgAEkUKEmNyZWF0ZV9hdWRpb190", - "cmFjaxgQIAEoCzInLmxpdmVraXQucHJvdG8uQ3JlYXRlQXVkaW9UcmFja1Jl", - "c3BvbnNlSAASQQoQbG9jYWxfdHJhY2tfbXV0ZRgRIAEoCzIlLmxpdmVraXQu", - "cHJvdG8uTG9jYWxUcmFja011dGVSZXNwb25zZUgAEkcKE2VuYWJsZV9yZW1v", - "dGVfdHJhY2sYEiABKAsyKC5saXZla2l0LnByb3RvLkVuYWJsZVJlbW90ZVRy", - "YWNrUmVzcG9uc2VIABI0CglnZXRfc3RhdHMYEyABKAsyHy5saXZla2l0LnBy", - "b3RvLkdldFN0YXRzUmVzcG9uc2VIABJBChBuZXdfdmlkZW9fc3RyZWFtGBQg", - "ASgLMiUubGl2ZWtpdC5wcm90by5OZXdWaWRlb1N0cmVhbVJlc3BvbnNlSAAS", - "QQoQbmV3X3ZpZGVvX3NvdXJjZRgVIAEoCzIlLmxpdmVraXQucHJvdG8uTmV3", - "VmlkZW9Tb3VyY2VSZXNwb25zZUgAEkcKE2NhcHR1cmVfdmlkZW9fZnJhbWUY", - "FiABKAsyKC5saXZla2l0LnByb3RvLkNhcHR1cmVWaWRlb0ZyYW1lUmVzcG9u", - "c2VIABI8Cg12aWRlb19jb252ZXJ0GBcgASgLMiMubGl2ZWtpdC5wcm90by5W", - "aWRlb0NvbnZlcnRSZXNwb25zZUgAEloKHXZpZGVvX3N0cmVhbV9mcm9tX3Bh", - "cnRpY2lwYW50GBggASgLMjEubGl2ZWtpdC5wcm90by5WaWRlb1N0cmVhbUZy", - "b21QYXJ0aWNpcGFudFJlc3BvbnNlSAASQQoQbmV3X2F1ZGlvX3N0cmVhbRgZ", - "IAEoCzIlLmxpdmVraXQucHJvdG8uTmV3QXVkaW9TdHJlYW1SZXNwb25zZUgA", - "EkEKEG5ld19hdWRpb19zb3VyY2UYGiABKAsyJS5saXZla2l0LnByb3RvLk5l", - "d0F1ZGlvU291cmNlUmVzcG9uc2VIABJHChNjYXB0dXJlX2F1ZGlvX2ZyYW1l", - "GBsgASgLMigubGl2ZWtpdC5wcm90by5DYXB0dXJlQXVkaW9GcmFtZVJlc3Bv", - "bnNlSAASRQoSY2xlYXJfYXVkaW9fYnVmZmVyGBwgASgLMicubGl2ZWtpdC5w", - "cm90by5DbGVhckF1ZGlvQnVmZmVyUmVzcG9uc2VIABJHChNuZXdfYXVkaW9f", - "cmVzYW1wbGVyGB0gASgLMigubGl2ZWtpdC5wcm90by5OZXdBdWRpb1Jlc2Ft", - "cGxlclJlc3BvbnNlSAASRQoScmVtaXhfYW5kX3Jlc2FtcGxlGB4gASgLMicu", - "bGl2ZWtpdC5wcm90by5SZW1peEFuZFJlc2FtcGxlUmVzcG9uc2VIABJaCh1h", - "dWRpb19zdHJlYW1fZnJvbV9wYXJ0aWNpcGFudBgfIAEoCzIxLmxpdmVraXQu", - "cHJvdG8uQXVkaW9TdHJlYW1Gcm9tUGFydGljaXBhbnRSZXNwb25zZUgAEisK", - "BGUyZWUYICABKAsyGy5saXZla2l0LnByb3RvLkUyZWVSZXNwb25zZUgAEkMK", - "EW5ld19zb3hfcmVzYW1wbGVyGCEgASgLMiYubGl2ZWtpdC5wcm90by5OZXdT", - "b3hSZXNhbXBsZXJSZXNwb25zZUgAEkUKEnB1c2hfc294X3Jlc2FtcGxlchgi", - "IAEoCzInLmxpdmVraXQucHJvdG8uUHVzaFNveFJlc2FtcGxlclJlc3BvbnNl", - "SAASRwoTZmx1c2hfc294X3Jlc2FtcGxlchgjIAEoCzIoLmxpdmVraXQucHJv", - "dG8uRmx1c2hTb3hSZXNhbXBsZXJSZXNwb25zZUgAEkMKEXNlbmRfY2hhdF9t", - "ZXNzYWdlGCQgASgLMiYubGl2ZWtpdC5wcm90by5TZW5kQ2hhdE1lc3NhZ2VS", - "ZXNwb25zZUgAEjgKC3BlcmZvcm1fcnBjGCUgASgLMiEubGl2ZWtpdC5wcm90", - "by5QZXJmb3JtUnBjUmVzcG9uc2VIABJHChNyZWdpc3Rlcl9ycGNfbWV0aG9k", - "GCYgASgLMigubGl2ZWtpdC5wcm90by5SZWdpc3RlclJwY01ldGhvZFJlc3Bv", - "bnNlSAASSwoVdW5yZWdpc3Rlcl9ycGNfbWV0aG9kGCcgASgLMioubGl2ZWtp", - "dC5wcm90by5VbnJlZ2lzdGVyUnBjTWV0aG9kUmVzcG9uc2VIABJcCh5ycGNf", - "bWV0aG9kX2ludm9jYXRpb25fcmVzcG9uc2UYKCABKAsyMi5saXZla2l0LnBy", - "b3RvLlJwY01ldGhvZEludm9jYXRpb25SZXNwb25zZVJlc3BvbnNlSABCCQoH", - "bWVzc2FnZSKKCwoIRmZpRXZlbnQSLgoKcm9vbV9ldmVudBgBIAEoCzIYLmxp", - "dmVraXQucHJvdG8uUm9vbUV2ZW50SAASMAoLdHJhY2tfZXZlbnQYAiABKAsy", - "GS5saXZla2l0LnByb3RvLlRyYWNrRXZlbnRIABI9ChJ2aWRlb19zdHJlYW1f", - "ZXZlbnQYAyABKAsyHy5saXZla2l0LnByb3RvLlZpZGVvU3RyZWFtRXZlbnRI", - "ABI9ChJhdWRpb19zdHJlYW1fZXZlbnQYBCABKAsyHy5saXZla2l0LnByb3Rv", - "LkF1ZGlvU3RyZWFtRXZlbnRIABIxCgdjb25uZWN0GAUgASgLMh4ubGl2ZWtp", - "dC5wcm90by5Db25uZWN0Q2FsbGJhY2tIABI3CgpkaXNjb25uZWN0GAcgASgL", - "MiEubGl2ZWtpdC5wcm90by5EaXNjb25uZWN0Q2FsbGJhY2tIABIxCgdkaXNw", - "b3NlGAggASgLMh4ubGl2ZWtpdC5wcm90by5EaXNwb3NlQ2FsbGJhY2tIABI8", - "Cg1wdWJsaXNoX3RyYWNrGAkgASgLMiMubGl2ZWtpdC5wcm90by5QdWJsaXNo", - "VHJhY2tDYWxsYmFja0gAEkAKD3VucHVibGlzaF90cmFjaxgKIAEoCzIlLmxp", - "dmVraXQucHJvdG8uVW5wdWJsaXNoVHJhY2tDYWxsYmFja0gAEjoKDHB1Ymxp", - "c2hfZGF0YRgLIAEoCzIiLmxpdmVraXQucHJvdG8uUHVibGlzaERhdGFDYWxs", - "YmFja0gAEkwKFXB1Ymxpc2hfdHJhbnNjcmlwdGlvbhgMIAEoCzIrLmxpdmVr", - "aXQucHJvdG8uUHVibGlzaFRyYW5zY3JpcHRpb25DYWxsYmFja0gAEkcKE2Nh", - "cHR1cmVfYXVkaW9fZnJhbWUYDSABKAsyKC5saXZla2l0LnByb3RvLkNhcHR1", - "cmVBdWRpb0ZyYW1lQ2FsbGJhY2tIABJFChJzZXRfbG9jYWxfbWV0YWRhdGEY", - "DiABKAsyJy5saXZla2l0LnByb3RvLlNldExvY2FsTWV0YWRhdGFDYWxsYmFj", - "a0gAEj0KDnNldF9sb2NhbF9uYW1lGA8gASgLMiMubGl2ZWtpdC5wcm90by5T", - "ZXRMb2NhbE5hbWVDYWxsYmFja0gAEkkKFHNldF9sb2NhbF9hdHRyaWJ1dGVz", - "GBAgASgLMikubGl2ZWtpdC5wcm90by5TZXRMb2NhbEF0dHJpYnV0ZXNDYWxs", - "YmFja0gAEjQKCWdldF9zdGF0cxgRIAEoCzIfLmxpdmVraXQucHJvdG8uR2V0", - "U3RhdHNDYWxsYmFja0gAEicKBGxvZ3MYEiABKAsyFy5saXZla2l0LnByb3Rv", - "LkxvZ0JhdGNoSAASQwoRZ2V0X3Nlc3Npb25fc3RhdHMYEyABKAsyJi5saXZl", - "a2l0LnByb3RvLkdldFNlc3Npb25TdGF0c0NhbGxiYWNrSAASJQoFcGFuaWMY", - "FCABKAsyFC5saXZla2l0LnByb3RvLlBhbmljSAASQQoQcHVibGlzaF9zaXBf", - "ZHRtZhgVIAEoCzIlLmxpdmVraXQucHJvdG8uUHVibGlzaFNpcER0bWZDYWxs", - "YmFja0gAEj4KDGNoYXRfbWVzc2FnZRgWIAEoCzImLmxpdmVraXQucHJvdG8u", - "U2VuZENoYXRNZXNzYWdlQ2FsbGJhY2tIABI4CgtwZXJmb3JtX3JwYxgXIAEo", - "CzIhLmxpdmVraXQucHJvdG8uUGVyZm9ybVJwY0NhbGxiYWNrSAASSAoVcnBj", - "X21ldGhvZF9pbnZvY2F0aW9uGBggASgLMicubGl2ZWtpdC5wcm90by5ScGNN", - "ZXRob2RJbnZvY2F0aW9uRXZlbnRIAEIJCgdtZXNzYWdlIh8KDkRpc3Bvc2VS", - "ZXF1ZXN0Eg0KBWFzeW5jGAEgAigIIiMKD0Rpc3Bvc2VSZXNwb25zZRIQCghh", - "c3luY19pZBgBIAEoBCIjCg9EaXNwb3NlQ2FsbGJhY2sSEAoIYXN5bmNfaWQY", - "ASACKAQihQEKCUxvZ1JlY29yZBImCgVsZXZlbBgBIAIoDjIXLmxpdmVraXQu", - "cHJvdG8uTG9nTGV2ZWwSDgoGdGFyZ2V0GAIgAigJEhMKC21vZHVsZV9wYXRo", - "GAMgASgJEgwKBGZpbGUYBCABKAkSDAoEbGluZRgFIAEoDRIPCgdtZXNzYWdl", - "GAYgAigJIjUKCExvZ0JhdGNoEikKB3JlY29yZHMYASADKAsyGC5saXZla2l0", - "LnByb3RvLkxvZ1JlY29yZCIYCgVQYW5pYxIPCgdtZXNzYWdlGAEgAigJKlMK", - "CExvZ0xldmVsEg0KCUxPR19FUlJPUhAAEgwKCExPR19XQVJOEAESDAoITE9H", - "X0lORk8QAhINCglMT0dfREVCVUcQAxINCglMT0dfVFJBQ0UQBEIQqgINTGl2", - "ZUtpdC5Qcm90bw==")); + "LnByb3RvGhd0cmFja19wdWJsaWNhdGlvbi5wcm90bxoKcm9vbS5wcm90bxoR", + "dmlkZW9fZnJhbWUucHJvdG8aEWF1ZGlvX2ZyYW1lLnByb3RvGglycGMucHJv", + "dG8aEWRhdGFfc3RyZWFtLnByb3RvIsEkCgpGZmlSZXF1ZXN0EjAKB2Rpc3Bv", + "c2UYAiABKAsyHS5saXZla2l0LnByb3RvLkRpc3Bvc2VSZXF1ZXN0SAASMAoH", + "Y29ubmVjdBgDIAEoCzIdLmxpdmVraXQucHJvdG8uQ29ubmVjdFJlcXVlc3RI", + "ABI2CgpkaXNjb25uZWN0GAQgASgLMiAubGl2ZWtpdC5wcm90by5EaXNjb25u", + "ZWN0UmVxdWVzdEgAEjsKDXB1Ymxpc2hfdHJhY2sYBSABKAsyIi5saXZla2l0", + "LnByb3RvLlB1Ymxpc2hUcmFja1JlcXVlc3RIABI/Cg91bnB1Ymxpc2hfdHJh", + "Y2sYBiABKAsyJC5saXZla2l0LnByb3RvLlVucHVibGlzaFRyYWNrUmVxdWVz", + "dEgAEjkKDHB1Ymxpc2hfZGF0YRgHIAEoCzIhLmxpdmVraXQucHJvdG8uUHVi", + "bGlzaERhdGFSZXF1ZXN0SAASPQoOc2V0X3N1YnNjcmliZWQYCCABKAsyIy5s", + "aXZla2l0LnByb3RvLlNldFN1YnNjcmliZWRSZXF1ZXN0SAASRAoSc2V0X2xv", + "Y2FsX21ldGFkYXRhGAkgASgLMiYubGl2ZWtpdC5wcm90by5TZXRMb2NhbE1l", + "dGFkYXRhUmVxdWVzdEgAEjwKDnNldF9sb2NhbF9uYW1lGAogASgLMiIubGl2", + "ZWtpdC5wcm90by5TZXRMb2NhbE5hbWVSZXF1ZXN0SAASSAoUc2V0X2xvY2Fs", + "X2F0dHJpYnV0ZXMYCyABKAsyKC5saXZla2l0LnByb3RvLlNldExvY2FsQXR0", + "cmlidXRlc1JlcXVlc3RIABJCChFnZXRfc2Vzc2lvbl9zdGF0cxgMIAEoCzIl", + "LmxpdmVraXQucHJvdG8uR2V0U2Vzc2lvblN0YXRzUmVxdWVzdEgAEksKFXB1", + "Ymxpc2hfdHJhbnNjcmlwdGlvbhgNIAEoCzIqLmxpdmVraXQucHJvdG8uUHVi", + "bGlzaFRyYW5zY3JpcHRpb25SZXF1ZXN0SAASQAoQcHVibGlzaF9zaXBfZHRt", + "ZhgOIAEoCzIkLmxpdmVraXQucHJvdG8uUHVibGlzaFNpcER0bWZSZXF1ZXN0", + "SAASRAoSY3JlYXRlX3ZpZGVvX3RyYWNrGA8gASgLMiYubGl2ZWtpdC5wcm90", + "by5DcmVhdGVWaWRlb1RyYWNrUmVxdWVzdEgAEkQKEmNyZWF0ZV9hdWRpb190", + "cmFjaxgQIAEoCzImLmxpdmVraXQucHJvdG8uQ3JlYXRlQXVkaW9UcmFja1Jl", + "cXVlc3RIABJAChBsb2NhbF90cmFja19tdXRlGBEgASgLMiQubGl2ZWtpdC5w", + "cm90by5Mb2NhbFRyYWNrTXV0ZVJlcXVlc3RIABJGChNlbmFibGVfcmVtb3Rl", + "X3RyYWNrGBIgASgLMicubGl2ZWtpdC5wcm90by5FbmFibGVSZW1vdGVUcmFj", + "a1JlcXVlc3RIABIzCglnZXRfc3RhdHMYEyABKAsyHi5saXZla2l0LnByb3Rv", + "LkdldFN0YXRzUmVxdWVzdEgAEmMKInNldF90cmFja19zdWJzY3JpcHRpb25f", + "cGVybWlzc2lvbnMYMCABKAsyNS5saXZla2l0LnByb3RvLlNldFRyYWNrU3Vi", + "c2NyaXB0aW9uUGVybWlzc2lvbnNSZXF1ZXN0SAASQAoQbmV3X3ZpZGVvX3N0", + "cmVhbRgUIAEoCzIkLmxpdmVraXQucHJvdG8uTmV3VmlkZW9TdHJlYW1SZXF1", + "ZXN0SAASQAoQbmV3X3ZpZGVvX3NvdXJjZRgVIAEoCzIkLmxpdmVraXQucHJv", + "dG8uTmV3VmlkZW9Tb3VyY2VSZXF1ZXN0SAASRgoTY2FwdHVyZV92aWRlb19m", + "cmFtZRgWIAEoCzInLmxpdmVraXQucHJvdG8uQ2FwdHVyZVZpZGVvRnJhbWVS", + "ZXF1ZXN0SAASOwoNdmlkZW9fY29udmVydBgXIAEoCzIiLmxpdmVraXQucHJv", + "dG8uVmlkZW9Db252ZXJ0UmVxdWVzdEgAElkKHXZpZGVvX3N0cmVhbV9mcm9t", + "X3BhcnRpY2lwYW50GBggASgLMjAubGl2ZWtpdC5wcm90by5WaWRlb1N0cmVh", + "bUZyb21QYXJ0aWNpcGFudFJlcXVlc3RIABJAChBuZXdfYXVkaW9fc3RyZWFt", + "GBkgASgLMiQubGl2ZWtpdC5wcm90by5OZXdBdWRpb1N0cmVhbVJlcXVlc3RI", + "ABJAChBuZXdfYXVkaW9fc291cmNlGBogASgLMiQubGl2ZWtpdC5wcm90by5O", + "ZXdBdWRpb1NvdXJjZVJlcXVlc3RIABJGChNjYXB0dXJlX2F1ZGlvX2ZyYW1l", + "GBsgASgLMicubGl2ZWtpdC5wcm90by5DYXB0dXJlQXVkaW9GcmFtZVJlcXVl", + "c3RIABJEChJjbGVhcl9hdWRpb19idWZmZXIYHCABKAsyJi5saXZla2l0LnBy", + "b3RvLkNsZWFyQXVkaW9CdWZmZXJSZXF1ZXN0SAASRgoTbmV3X2F1ZGlvX3Jl", + "c2FtcGxlchgdIAEoCzInLmxpdmVraXQucHJvdG8uTmV3QXVkaW9SZXNhbXBs", + "ZXJSZXF1ZXN0SAASRAoScmVtaXhfYW5kX3Jlc2FtcGxlGB4gASgLMiYubGl2", + "ZWtpdC5wcm90by5SZW1peEFuZFJlc2FtcGxlUmVxdWVzdEgAEioKBGUyZWUY", + "HyABKAsyGi5saXZla2l0LnByb3RvLkUyZWVSZXF1ZXN0SAASWQodYXVkaW9f", + "c3RyZWFtX2Zyb21fcGFydGljaXBhbnQYICABKAsyMC5saXZla2l0LnByb3Rv", + "LkF1ZGlvU3RyZWFtRnJvbVBhcnRpY2lwYW50UmVxdWVzdEgAEkIKEW5ld19z", + "b3hfcmVzYW1wbGVyGCEgASgLMiUubGl2ZWtpdC5wcm90by5OZXdTb3hSZXNh", + "bXBsZXJSZXF1ZXN0SAASRAoScHVzaF9zb3hfcmVzYW1wbGVyGCIgASgLMiYu", + "bGl2ZWtpdC5wcm90by5QdXNoU294UmVzYW1wbGVyUmVxdWVzdEgAEkYKE2Zs", + "dXNoX3NveF9yZXNhbXBsZXIYIyABKAsyJy5saXZla2l0LnByb3RvLkZsdXNo", + "U294UmVzYW1wbGVyUmVxdWVzdEgAEkIKEXNlbmRfY2hhdF9tZXNzYWdlGCQg", + "ASgLMiUubGl2ZWtpdC5wcm90by5TZW5kQ2hhdE1lc3NhZ2VSZXF1ZXN0SAAS", + "QgoRZWRpdF9jaGF0X21lc3NhZ2UYJSABKAsyJS5saXZla2l0LnByb3RvLkVk", + "aXRDaGF0TWVzc2FnZVJlcXVlc3RIABI3CgtwZXJmb3JtX3JwYxgmIAEoCzIg", + "LmxpdmVraXQucHJvdG8uUGVyZm9ybVJwY1JlcXVlc3RIABJGChNyZWdpc3Rl", + "cl9ycGNfbWV0aG9kGCcgASgLMicubGl2ZWtpdC5wcm90by5SZWdpc3RlclJw", + "Y01ldGhvZFJlcXVlc3RIABJKChV1bnJlZ2lzdGVyX3JwY19tZXRob2QYKCAB", + "KAsyKS5saXZla2l0LnByb3RvLlVucmVnaXN0ZXJScGNNZXRob2RSZXF1ZXN0", + "SAASWwoecnBjX21ldGhvZF9pbnZvY2F0aW9uX3Jlc3BvbnNlGCkgASgLMjEu", + "bGl2ZWtpdC5wcm90by5ScGNNZXRob2RJbnZvY2F0aW9uUmVzcG9uc2VSZXF1", + "ZXN0SAASXQofZW5hYmxlX3JlbW90ZV90cmFja19wdWJsaWNhdGlvbhgqIAEo", + "CzIyLmxpdmVraXQucHJvdG8uRW5hYmxlUmVtb3RlVHJhY2tQdWJsaWNhdGlv", + "blJlcXVlc3RIABJwCil1cGRhdGVfcmVtb3RlX3RyYWNrX3B1YmxpY2F0aW9u", + "X2RpbWVuc2lvbhgrIAEoCzI7LmxpdmVraXQucHJvdG8uVXBkYXRlUmVtb3Rl", + "VHJhY2tQdWJsaWNhdGlvbkRpbWVuc2lvblJlcXVlc3RIABJEChJzZW5kX3N0", + "cmVhbV9oZWFkZXIYLCABKAsyJi5saXZla2l0LnByb3RvLlNlbmRTdHJlYW1I", + "ZWFkZXJSZXF1ZXN0SAASQgoRc2VuZF9zdHJlYW1fY2h1bmsYLSABKAsyJS5s", + "aXZla2l0LnByb3RvLlNlbmRTdHJlYW1DaHVua1JlcXVlc3RIABJGChNzZW5k", + "X3N0cmVhbV90cmFpbGVyGC4gASgLMicubGl2ZWtpdC5wcm90by5TZW5kU3Ry", + "ZWFtVHJhaWxlclJlcXVlc3RIABJ4Ci5zZXRfZGF0YV9jaGFubmVsX2J1ZmZl", + "cmVkX2Ftb3VudF9sb3dfdGhyZXNob2xkGC8gASgLMj4ubGl2ZWtpdC5wcm90", + "by5TZXREYXRhQ2hhbm5lbEJ1ZmZlcmVkQW1vdW50TG93VGhyZXNob2xkUmVx", + "dWVzdEgAEk8KGGxvYWRfYXVkaW9fZmlsdGVyX3BsdWdpbhgxIAEoCzIrLmxp", + "dmVraXQucHJvdG8uTG9hZEF1ZGlvRmlsdGVyUGx1Z2luUmVxdWVzdEgAEi8K", + "B25ld19hcG0YMiABKAsyHC5saXZla2l0LnByb3RvLk5ld0FwbVJlcXVlc3RI", + "ABJEChJhcG1fcHJvY2Vzc19zdHJlYW0YMyABKAsyJi5saXZla2l0LnByb3Rv", + "LkFwbVByb2Nlc3NTdHJlYW1SZXF1ZXN0SAASUwoaYXBtX3Byb2Nlc3NfcmV2", + "ZXJzZV9zdHJlYW0YNCABKAsyLS5saXZla2l0LnByb3RvLkFwbVByb2Nlc3NS", + "ZXZlcnNlU3RyZWFtUmVxdWVzdEgAEkcKFGFwbV9zZXRfc3RyZWFtX2RlbGF5", + "GDUgASgLMicubGl2ZWtpdC5wcm90by5BcG1TZXRTdHJlYW1EZWxheVJlcXVl", + "c3RIABJWChVieXRlX3JlYWRfaW5jcmVtZW50YWwYNiABKAsyNS5saXZla2l0", + "LnByb3RvLkJ5dGVTdHJlYW1SZWFkZXJSZWFkSW5jcmVtZW50YWxSZXF1ZXN0", + "SAASRgoNYnl0ZV9yZWFkX2FsbBg3IAEoCzItLmxpdmVraXQucHJvdG8uQnl0", + "ZVN0cmVhbVJlYWRlclJlYWRBbGxSZXF1ZXN0SAASTwoSYnl0ZV93cml0ZV90", + "b19maWxlGDggASgLMjEubGl2ZWtpdC5wcm90by5CeXRlU3RyZWFtUmVhZGVy", + "V3JpdGVUb0ZpbGVSZXF1ZXN0SAASVgoVdGV4dF9yZWFkX2luY3JlbWVudGFs", + "GDkgASgLMjUubGl2ZWtpdC5wcm90by5UZXh0U3RyZWFtUmVhZGVyUmVhZElu", + "Y3JlbWVudGFsUmVxdWVzdEgAEkYKDXRleHRfcmVhZF9hbGwYOiABKAsyLS5s", + "aXZla2l0LnByb3RvLlRleHRTdHJlYW1SZWFkZXJSZWFkQWxsUmVxdWVzdEgA", + "EjkKCXNlbmRfZmlsZRg7IAEoCzIkLmxpdmVraXQucHJvdG8uU3RyZWFtU2Vu", + "ZEZpbGVSZXF1ZXN0SAASOQoJc2VuZF90ZXh0GDwgASgLMiQubGl2ZWtpdC5w", + "cm90by5TdHJlYW1TZW5kVGV4dFJlcXVlc3RIABJAChBieXRlX3N0cmVhbV9v", + "cGVuGD0gASgLMiQubGl2ZWtpdC5wcm90by5CeXRlU3RyZWFtT3BlblJlcXVl", + "c3RIABJIChFieXRlX3N0cmVhbV93cml0ZRg+IAEoCzIrLmxpdmVraXQucHJv", + "dG8uQnl0ZVN0cmVhbVdyaXRlcldyaXRlUmVxdWVzdEgAEkgKEWJ5dGVfc3Ry", + "ZWFtX2Nsb3NlGD8gASgLMisubGl2ZWtpdC5wcm90by5CeXRlU3RyZWFtV3Jp", + "dGVyQ2xvc2VSZXF1ZXN0SAASQAoQdGV4dF9zdHJlYW1fb3BlbhhAIAEoCzIk", + "LmxpdmVraXQucHJvdG8uVGV4dFN0cmVhbU9wZW5SZXF1ZXN0SAASSAoRdGV4", + "dF9zdHJlYW1fd3JpdGUYQSABKAsyKy5saXZla2l0LnByb3RvLlRleHRTdHJl", + "YW1Xcml0ZXJXcml0ZVJlcXVlc3RIABJIChF0ZXh0X3N0cmVhbV9jbG9zZRhC", + "IAEoCzIrLmxpdmVraXQucHJvdG8uVGV4dFN0cmVhbVdyaXRlckNsb3NlUmVx", + "dWVzdEgAQgkKB21lc3NhZ2UiviQKC0ZmaVJlc3BvbnNlEjEKB2Rpc3Bvc2UY", + "AiABKAsyHi5saXZla2l0LnByb3RvLkRpc3Bvc2VSZXNwb25zZUgAEjEKB2Nv", + "bm5lY3QYAyABKAsyHi5saXZla2l0LnByb3RvLkNvbm5lY3RSZXNwb25zZUgA", + "EjcKCmRpc2Nvbm5lY3QYBCABKAsyIS5saXZla2l0LnByb3RvLkRpc2Nvbm5l", + "Y3RSZXNwb25zZUgAEjwKDXB1Ymxpc2hfdHJhY2sYBSABKAsyIy5saXZla2l0", + "LnByb3RvLlB1Ymxpc2hUcmFja1Jlc3BvbnNlSAASQAoPdW5wdWJsaXNoX3Ry", + "YWNrGAYgASgLMiUubGl2ZWtpdC5wcm90by5VbnB1Ymxpc2hUcmFja1Jlc3Bv", + "bnNlSAASOgoMcHVibGlzaF9kYXRhGAcgASgLMiIubGl2ZWtpdC5wcm90by5Q", + "dWJsaXNoRGF0YVJlc3BvbnNlSAASPgoOc2V0X3N1YnNjcmliZWQYCCABKAsy", + "JC5saXZla2l0LnByb3RvLlNldFN1YnNjcmliZWRSZXNwb25zZUgAEkUKEnNl", + "dF9sb2NhbF9tZXRhZGF0YRgJIAEoCzInLmxpdmVraXQucHJvdG8uU2V0TG9j", + "YWxNZXRhZGF0YVJlc3BvbnNlSAASPQoOc2V0X2xvY2FsX25hbWUYCiABKAsy", + "Iy5saXZla2l0LnByb3RvLlNldExvY2FsTmFtZVJlc3BvbnNlSAASSQoUc2V0", + "X2xvY2FsX2F0dHJpYnV0ZXMYCyABKAsyKS5saXZla2l0LnByb3RvLlNldExv", + "Y2FsQXR0cmlidXRlc1Jlc3BvbnNlSAASQwoRZ2V0X3Nlc3Npb25fc3RhdHMY", + "DCABKAsyJi5saXZla2l0LnByb3RvLkdldFNlc3Npb25TdGF0c1Jlc3BvbnNl", + "SAASTAoVcHVibGlzaF90cmFuc2NyaXB0aW9uGA0gASgLMisubGl2ZWtpdC5w", + "cm90by5QdWJsaXNoVHJhbnNjcmlwdGlvblJlc3BvbnNlSAASQQoQcHVibGlz", + "aF9zaXBfZHRtZhgOIAEoCzIlLmxpdmVraXQucHJvdG8uUHVibGlzaFNpcER0", + "bWZSZXNwb25zZUgAEkUKEmNyZWF0ZV92aWRlb190cmFjaxgPIAEoCzInLmxp", + "dmVraXQucHJvdG8uQ3JlYXRlVmlkZW9UcmFja1Jlc3BvbnNlSAASRQoSY3Jl", + "YXRlX2F1ZGlvX3RyYWNrGBAgASgLMicubGl2ZWtpdC5wcm90by5DcmVhdGVB", + "dWRpb1RyYWNrUmVzcG9uc2VIABJBChBsb2NhbF90cmFja19tdXRlGBEgASgL", + "MiUubGl2ZWtpdC5wcm90by5Mb2NhbFRyYWNrTXV0ZVJlc3BvbnNlSAASRwoT", + "ZW5hYmxlX3JlbW90ZV90cmFjaxgSIAEoCzIoLmxpdmVraXQucHJvdG8uRW5h", + "YmxlUmVtb3RlVHJhY2tSZXNwb25zZUgAEjQKCWdldF9zdGF0cxgTIAEoCzIf", + "LmxpdmVraXQucHJvdG8uR2V0U3RhdHNSZXNwb25zZUgAEmQKInNldF90cmFj", + "a19zdWJzY3JpcHRpb25fcGVybWlzc2lvbnMYLyABKAsyNi5saXZla2l0LnBy", + "b3RvLlNldFRyYWNrU3Vic2NyaXB0aW9uUGVybWlzc2lvbnNSZXNwb25zZUgA", + "EkEKEG5ld192aWRlb19zdHJlYW0YFCABKAsyJS5saXZla2l0LnByb3RvLk5l", + "d1ZpZGVvU3RyZWFtUmVzcG9uc2VIABJBChBuZXdfdmlkZW9fc291cmNlGBUg", + "ASgLMiUubGl2ZWtpdC5wcm90by5OZXdWaWRlb1NvdXJjZVJlc3BvbnNlSAAS", + "RwoTY2FwdHVyZV92aWRlb19mcmFtZRgWIAEoCzIoLmxpdmVraXQucHJvdG8u", + "Q2FwdHVyZVZpZGVvRnJhbWVSZXNwb25zZUgAEjwKDXZpZGVvX2NvbnZlcnQY", + "FyABKAsyIy5saXZla2l0LnByb3RvLlZpZGVvQ29udmVydFJlc3BvbnNlSAAS", + "WgoddmlkZW9fc3RyZWFtX2Zyb21fcGFydGljaXBhbnQYGCABKAsyMS5saXZl", + "a2l0LnByb3RvLlZpZGVvU3RyZWFtRnJvbVBhcnRpY2lwYW50UmVzcG9uc2VI", + "ABJBChBuZXdfYXVkaW9fc3RyZWFtGBkgASgLMiUubGl2ZWtpdC5wcm90by5O", + "ZXdBdWRpb1N0cmVhbVJlc3BvbnNlSAASQQoQbmV3X2F1ZGlvX3NvdXJjZRga", + "IAEoCzIlLmxpdmVraXQucHJvdG8uTmV3QXVkaW9Tb3VyY2VSZXNwb25zZUgA", + "EkcKE2NhcHR1cmVfYXVkaW9fZnJhbWUYGyABKAsyKC5saXZla2l0LnByb3Rv", + "LkNhcHR1cmVBdWRpb0ZyYW1lUmVzcG9uc2VIABJFChJjbGVhcl9hdWRpb19i", + "dWZmZXIYHCABKAsyJy5saXZla2l0LnByb3RvLkNsZWFyQXVkaW9CdWZmZXJS", + "ZXNwb25zZUgAEkcKE25ld19hdWRpb19yZXNhbXBsZXIYHSABKAsyKC5saXZl", + "a2l0LnByb3RvLk5ld0F1ZGlvUmVzYW1wbGVyUmVzcG9uc2VIABJFChJyZW1p", + "eF9hbmRfcmVzYW1wbGUYHiABKAsyJy5saXZla2l0LnByb3RvLlJlbWl4QW5k", + "UmVzYW1wbGVSZXNwb25zZUgAEloKHWF1ZGlvX3N0cmVhbV9mcm9tX3BhcnRp", + "Y2lwYW50GB8gASgLMjEubGl2ZWtpdC5wcm90by5BdWRpb1N0cmVhbUZyb21Q", + "YXJ0aWNpcGFudFJlc3BvbnNlSAASKwoEZTJlZRggIAEoCzIbLmxpdmVraXQu", + "cHJvdG8uRTJlZVJlc3BvbnNlSAASQwoRbmV3X3NveF9yZXNhbXBsZXIYISAB", + "KAsyJi5saXZla2l0LnByb3RvLk5ld1NveFJlc2FtcGxlclJlc3BvbnNlSAAS", + "RQoScHVzaF9zb3hfcmVzYW1wbGVyGCIgASgLMicubGl2ZWtpdC5wcm90by5Q", + "dXNoU294UmVzYW1wbGVyUmVzcG9uc2VIABJHChNmbHVzaF9zb3hfcmVzYW1w", + "bGVyGCMgASgLMigubGl2ZWtpdC5wcm90by5GbHVzaFNveFJlc2FtcGxlclJl", + "c3BvbnNlSAASQwoRc2VuZF9jaGF0X21lc3NhZ2UYJCABKAsyJi5saXZla2l0", + "LnByb3RvLlNlbmRDaGF0TWVzc2FnZVJlc3BvbnNlSAASOAoLcGVyZm9ybV9y", + "cGMYJSABKAsyIS5saXZla2l0LnByb3RvLlBlcmZvcm1ScGNSZXNwb25zZUgA", + "EkcKE3JlZ2lzdGVyX3JwY19tZXRob2QYJiABKAsyKC5saXZla2l0LnByb3Rv", + "LlJlZ2lzdGVyUnBjTWV0aG9kUmVzcG9uc2VIABJLChV1bnJlZ2lzdGVyX3Jw", + "Y19tZXRob2QYJyABKAsyKi5saXZla2l0LnByb3RvLlVucmVnaXN0ZXJScGNN", + "ZXRob2RSZXNwb25zZUgAElwKHnJwY19tZXRob2RfaW52b2NhdGlvbl9yZXNw", + "b25zZRgoIAEoCzIyLmxpdmVraXQucHJvdG8uUnBjTWV0aG9kSW52b2NhdGlv", + "blJlc3BvbnNlUmVzcG9uc2VIABJeCh9lbmFibGVfcmVtb3RlX3RyYWNrX3B1", + "YmxpY2F0aW9uGCkgASgLMjMubGl2ZWtpdC5wcm90by5FbmFibGVSZW1vdGVU", + "cmFja1B1YmxpY2F0aW9uUmVzcG9uc2VIABJxCil1cGRhdGVfcmVtb3RlX3Ry", + "YWNrX3B1YmxpY2F0aW9uX2RpbWVuc2lvbhgqIAEoCzI8LmxpdmVraXQucHJv", + "dG8uVXBkYXRlUmVtb3RlVHJhY2tQdWJsaWNhdGlvbkRpbWVuc2lvblJlc3Bv", + "bnNlSAASRQoSc2VuZF9zdHJlYW1faGVhZGVyGCsgASgLMicubGl2ZWtpdC5w", + "cm90by5TZW5kU3RyZWFtSGVhZGVyUmVzcG9uc2VIABJDChFzZW5kX3N0cmVh", + "bV9jaHVuaxgsIAEoCzImLmxpdmVraXQucHJvdG8uU2VuZFN0cmVhbUNodW5r", + "UmVzcG9uc2VIABJHChNzZW5kX3N0cmVhbV90cmFpbGVyGC0gASgLMigubGl2", + "ZWtpdC5wcm90by5TZW5kU3RyZWFtVHJhaWxlclJlc3BvbnNlSAASeQouc2V0", + "X2RhdGFfY2hhbm5lbF9idWZmZXJlZF9hbW91bnRfbG93X3RocmVzaG9sZBgu", + "IAEoCzI/LmxpdmVraXQucHJvdG8uU2V0RGF0YUNoYW5uZWxCdWZmZXJlZEFt", + "b3VudExvd1RocmVzaG9sZFJlc3BvbnNlSAASUAoYbG9hZF9hdWRpb19maWx0", + "ZXJfcGx1Z2luGDAgASgLMiwubGl2ZWtpdC5wcm90by5Mb2FkQXVkaW9GaWx0", + "ZXJQbHVnaW5SZXNwb25zZUgAEjAKB25ld19hcG0YMSABKAsyHS5saXZla2l0", + "LnByb3RvLk5ld0FwbVJlc3BvbnNlSAASRQoSYXBtX3Byb2Nlc3Nfc3RyZWFt", + "GDIgASgLMicubGl2ZWtpdC5wcm90by5BcG1Qcm9jZXNzU3RyZWFtUmVzcG9u", + "c2VIABJUChphcG1fcHJvY2Vzc19yZXZlcnNlX3N0cmVhbRgzIAEoCzIuLmxp", + "dmVraXQucHJvdG8uQXBtUHJvY2Vzc1JldmVyc2VTdHJlYW1SZXNwb25zZUgA", + "EkgKFGFwbV9zZXRfc3RyZWFtX2RlbGF5GDQgASgLMigubGl2ZWtpdC5wcm90", + "by5BcG1TZXRTdHJlYW1EZWxheVJlc3BvbnNlSAASVwoVYnl0ZV9yZWFkX2lu", + "Y3JlbWVudGFsGDUgASgLMjYubGl2ZWtpdC5wcm90by5CeXRlU3RyZWFtUmVh", + "ZGVyUmVhZEluY3JlbWVudGFsUmVzcG9uc2VIABJHCg1ieXRlX3JlYWRfYWxs", + "GDYgASgLMi4ubGl2ZWtpdC5wcm90by5CeXRlU3RyZWFtUmVhZGVyUmVhZEFs", + "bFJlc3BvbnNlSAASUAoSYnl0ZV93cml0ZV90b19maWxlGDcgASgLMjIubGl2", + "ZWtpdC5wcm90by5CeXRlU3RyZWFtUmVhZGVyV3JpdGVUb0ZpbGVSZXNwb25z", + "ZUgAElcKFXRleHRfcmVhZF9pbmNyZW1lbnRhbBg4IAEoCzI2LmxpdmVraXQu", + "cHJvdG8uVGV4dFN0cmVhbVJlYWRlclJlYWRJbmNyZW1lbnRhbFJlc3BvbnNl", + "SAASRwoNdGV4dF9yZWFkX2FsbBg5IAEoCzIuLmxpdmVraXQucHJvdG8uVGV4", + "dFN0cmVhbVJlYWRlclJlYWRBbGxSZXNwb25zZUgAEjoKCXNlbmRfZmlsZRg6", + "IAEoCzIlLmxpdmVraXQucHJvdG8uU3RyZWFtU2VuZEZpbGVSZXNwb25zZUgA", + "EjoKCXNlbmRfdGV4dBg7IAEoCzIlLmxpdmVraXQucHJvdG8uU3RyZWFtU2Vu", + "ZFRleHRSZXNwb25zZUgAEkEKEGJ5dGVfc3RyZWFtX29wZW4YPCABKAsyJS5s", + "aXZla2l0LnByb3RvLkJ5dGVTdHJlYW1PcGVuUmVzcG9uc2VIABJJChFieXRl", + "X3N0cmVhbV93cml0ZRg9IAEoCzIsLmxpdmVraXQucHJvdG8uQnl0ZVN0cmVh", + "bVdyaXRlcldyaXRlUmVzcG9uc2VIABJJChFieXRlX3N0cmVhbV9jbG9zZRg+", + "IAEoCzIsLmxpdmVraXQucHJvdG8uQnl0ZVN0cmVhbVdyaXRlckNsb3NlUmVz", + "cG9uc2VIABJBChB0ZXh0X3N0cmVhbV9vcGVuGD8gASgLMiUubGl2ZWtpdC5w", + "cm90by5UZXh0U3RyZWFtT3BlblJlc3BvbnNlSAASSQoRdGV4dF9zdHJlYW1f", + "d3JpdGUYQCABKAsyLC5saXZla2l0LnByb3RvLlRleHRTdHJlYW1Xcml0ZXJX", + "cml0ZVJlc3BvbnNlSAASSQoRdGV4dF9zdHJlYW1fY2xvc2UYQSABKAsyLC5s", + "aXZla2l0LnByb3RvLlRleHRTdHJlYW1Xcml0ZXJDbG9zZVJlc3BvbnNlSABC", + "CQoHbWVzc2FnZSLHFAoIRmZpRXZlbnQSLgoKcm9vbV9ldmVudBgBIAEoCzIY", + "LmxpdmVraXQucHJvdG8uUm9vbUV2ZW50SAASMAoLdHJhY2tfZXZlbnQYAiAB", + "KAsyGS5saXZla2l0LnByb3RvLlRyYWNrRXZlbnRIABI9ChJ2aWRlb19zdHJl", + "YW1fZXZlbnQYAyABKAsyHy5saXZla2l0LnByb3RvLlZpZGVvU3RyZWFtRXZl", + "bnRIABI9ChJhdWRpb19zdHJlYW1fZXZlbnQYBCABKAsyHy5saXZla2l0LnBy", + "b3RvLkF1ZGlvU3RyZWFtRXZlbnRIABIxCgdjb25uZWN0GAUgASgLMh4ubGl2", + "ZWtpdC5wcm90by5Db25uZWN0Q2FsbGJhY2tIABI3CgpkaXNjb25uZWN0GAcg", + "ASgLMiEubGl2ZWtpdC5wcm90by5EaXNjb25uZWN0Q2FsbGJhY2tIABIxCgdk", + "aXNwb3NlGAggASgLMh4ubGl2ZWtpdC5wcm90by5EaXNwb3NlQ2FsbGJhY2tI", + "ABI8Cg1wdWJsaXNoX3RyYWNrGAkgASgLMiMubGl2ZWtpdC5wcm90by5QdWJs", + "aXNoVHJhY2tDYWxsYmFja0gAEkAKD3VucHVibGlzaF90cmFjaxgKIAEoCzIl", + "LmxpdmVraXQucHJvdG8uVW5wdWJsaXNoVHJhY2tDYWxsYmFja0gAEjoKDHB1", + "Ymxpc2hfZGF0YRgLIAEoCzIiLmxpdmVraXQucHJvdG8uUHVibGlzaERhdGFD", + "YWxsYmFja0gAEkwKFXB1Ymxpc2hfdHJhbnNjcmlwdGlvbhgMIAEoCzIrLmxp", + "dmVraXQucHJvdG8uUHVibGlzaFRyYW5zY3JpcHRpb25DYWxsYmFja0gAEkcK", + "E2NhcHR1cmVfYXVkaW9fZnJhbWUYDSABKAsyKC5saXZla2l0LnByb3RvLkNh", + "cHR1cmVBdWRpb0ZyYW1lQ2FsbGJhY2tIABJFChJzZXRfbG9jYWxfbWV0YWRh", + "dGEYDiABKAsyJy5saXZla2l0LnByb3RvLlNldExvY2FsTWV0YWRhdGFDYWxs", + "YmFja0gAEj0KDnNldF9sb2NhbF9uYW1lGA8gASgLMiMubGl2ZWtpdC5wcm90", + "by5TZXRMb2NhbE5hbWVDYWxsYmFja0gAEkkKFHNldF9sb2NhbF9hdHRyaWJ1", + "dGVzGBAgASgLMikubGl2ZWtpdC5wcm90by5TZXRMb2NhbEF0dHJpYnV0ZXND", + "YWxsYmFja0gAEjQKCWdldF9zdGF0cxgRIAEoCzIfLmxpdmVraXQucHJvdG8u", + "R2V0U3RhdHNDYWxsYmFja0gAEicKBGxvZ3MYEiABKAsyFy5saXZla2l0LnBy", + "b3RvLkxvZ0JhdGNoSAASQwoRZ2V0X3Nlc3Npb25fc3RhdHMYEyABKAsyJi5s", + "aXZla2l0LnByb3RvLkdldFNlc3Npb25TdGF0c0NhbGxiYWNrSAASJQoFcGFu", + "aWMYFCABKAsyFC5saXZla2l0LnByb3RvLlBhbmljSAASQQoQcHVibGlzaF9z", + "aXBfZHRtZhgVIAEoCzIlLmxpdmVraXQucHJvdG8uUHVibGlzaFNpcER0bWZD", + "YWxsYmFja0gAEj4KDGNoYXRfbWVzc2FnZRgWIAEoCzImLmxpdmVraXQucHJv", + "dG8uU2VuZENoYXRNZXNzYWdlQ2FsbGJhY2tIABI4CgtwZXJmb3JtX3JwYxgX", + "IAEoCzIhLmxpdmVraXQucHJvdG8uUGVyZm9ybVJwY0NhbGxiYWNrSAASSAoV", + "cnBjX21ldGhvZF9pbnZvY2F0aW9uGBggASgLMicubGl2ZWtpdC5wcm90by5S", + "cGNNZXRob2RJbnZvY2F0aW9uRXZlbnRIABJFChJzZW5kX3N0cmVhbV9oZWFk", + "ZXIYGSABKAsyJy5saXZla2l0LnByb3RvLlNlbmRTdHJlYW1IZWFkZXJDYWxs", + "YmFja0gAEkMKEXNlbmRfc3RyZWFtX2NodW5rGBogASgLMiYubGl2ZWtpdC5w", + "cm90by5TZW5kU3RyZWFtQ2h1bmtDYWxsYmFja0gAEkcKE3NlbmRfc3RyZWFt", + "X3RyYWlsZXIYGyABKAsyKC5saXZla2l0LnByb3RvLlNlbmRTdHJlYW1UcmFp", + "bGVyQ2FsbGJhY2tIABJIChhieXRlX3N0cmVhbV9yZWFkZXJfZXZlbnQYHCAB", + "KAsyJC5saXZla2l0LnByb3RvLkJ5dGVTdHJlYW1SZWFkZXJFdmVudEgAElUK", + "G2J5dGVfc3RyZWFtX3JlYWRlcl9yZWFkX2FsbBgdIAEoCzIuLmxpdmVraXQu", + "cHJvdG8uQnl0ZVN0cmVhbVJlYWRlclJlYWRBbGxDYWxsYmFja0gAEl4KIGJ5", + "dGVfc3RyZWFtX3JlYWRlcl93cml0ZV90b19maWxlGB4gASgLMjIubGl2ZWtp", + "dC5wcm90by5CeXRlU3RyZWFtUmVhZGVyV3JpdGVUb0ZpbGVDYWxsYmFja0gA", + "EkEKEGJ5dGVfc3RyZWFtX29wZW4YHyABKAsyJS5saXZla2l0LnByb3RvLkJ5", + "dGVTdHJlYW1PcGVuQ2FsbGJhY2tIABJQChhieXRlX3N0cmVhbV93cml0ZXJf", + "d3JpdGUYICABKAsyLC5saXZla2l0LnByb3RvLkJ5dGVTdHJlYW1Xcml0ZXJX", + "cml0ZUNhbGxiYWNrSAASUAoYYnl0ZV9zdHJlYW1fd3JpdGVyX2Nsb3NlGCEg", + "ASgLMiwubGl2ZWtpdC5wcm90by5CeXRlU3RyZWFtV3JpdGVyQ2xvc2VDYWxs", + "YmFja0gAEjoKCXNlbmRfZmlsZRgiIAEoCzIlLmxpdmVraXQucHJvdG8uU3Ry", + "ZWFtU2VuZEZpbGVDYWxsYmFja0gAEkgKGHRleHRfc3RyZWFtX3JlYWRlcl9l", + "dmVudBgjIAEoCzIkLmxpdmVraXQucHJvdG8uVGV4dFN0cmVhbVJlYWRlckV2", + "ZW50SAASVQobdGV4dF9zdHJlYW1fcmVhZGVyX3JlYWRfYWxsGCQgASgLMi4u", + "bGl2ZWtpdC5wcm90by5UZXh0U3RyZWFtUmVhZGVyUmVhZEFsbENhbGxiYWNr", + "SAASQQoQdGV4dF9zdHJlYW1fb3BlbhglIAEoCzIlLmxpdmVraXQucHJvdG8u", + "VGV4dFN0cmVhbU9wZW5DYWxsYmFja0gAElAKGHRleHRfc3RyZWFtX3dyaXRl", + "cl93cml0ZRgmIAEoCzIsLmxpdmVraXQucHJvdG8uVGV4dFN0cmVhbVdyaXRl", + "cldyaXRlQ2FsbGJhY2tIABJQChh0ZXh0X3N0cmVhbV93cml0ZXJfY2xvc2UY", + "JyABKAsyLC5saXZla2l0LnByb3RvLlRleHRTdHJlYW1Xcml0ZXJDbG9zZUNh", + "bGxiYWNrSAASOgoJc2VuZF90ZXh0GCggASgLMiUubGl2ZWtpdC5wcm90by5T", + "dHJlYW1TZW5kVGV4dENhbGxiYWNrSABCCQoHbWVzc2FnZSIfCg5EaXNwb3Nl", + "UmVxdWVzdBINCgVhc3luYxgBIAIoCCIjCg9EaXNwb3NlUmVzcG9uc2USEAoI", + "YXN5bmNfaWQYASABKAQiIwoPRGlzcG9zZUNhbGxiYWNrEhAKCGFzeW5jX2lk", + "GAEgAigEIoUBCglMb2dSZWNvcmQSJgoFbGV2ZWwYASACKA4yFy5saXZla2l0", + "LnByb3RvLkxvZ0xldmVsEg4KBnRhcmdldBgCIAIoCRITCgttb2R1bGVfcGF0", + "aBgDIAEoCRIMCgRmaWxlGAQgASgJEgwKBGxpbmUYBSABKA0SDwoHbWVzc2Fn", + "ZRgGIAIoCSI1CghMb2dCYXRjaBIpCgdyZWNvcmRzGAEgAygLMhgubGl2ZWtp", + "dC5wcm90by5Mb2dSZWNvcmQiGAoFUGFuaWMSDwoHbWVzc2FnZRgBIAIoCSpT", + "CghMb2dMZXZlbBINCglMT0dfRVJST1IQABIMCghMT0dfV0FSThABEgwKCExP", + "R19JTkZPEAISDQoJTE9HX0RFQlVHEAMSDQoJTE9HX1RSQUNFEARCEKoCDUxp", + "dmVLaXQuUHJvdG8=")); descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData, - new pbr::FileDescriptor[] { global::LiveKit.Proto.E2EeReflection.Descriptor, global::LiveKit.Proto.TrackReflection.Descriptor, global::LiveKit.Proto.RoomReflection.Descriptor, global::LiveKit.Proto.VideoFrameReflection.Descriptor, global::LiveKit.Proto.AudioFrameReflection.Descriptor, global::LiveKit.Proto.RpcReflection.Descriptor, }, + new pbr::FileDescriptor[] { global::LiveKit.Proto.E2EeReflection.Descriptor, global::LiveKit.Proto.TrackReflection.Descriptor, global::LiveKit.Proto.TrackPublicationReflection.Descriptor, global::LiveKit.Proto.RoomReflection.Descriptor, global::LiveKit.Proto.VideoFrameReflection.Descriptor, global::LiveKit.Proto.AudioFrameReflection.Descriptor, global::LiveKit.Proto.RpcReflection.Descriptor, global::LiveKit.Proto.DataStreamReflection.Descriptor, }, new pbr::GeneratedClrTypeInfo(new[] {typeof(global::LiveKit.Proto.LogLevel), }, null, new pbr::GeneratedClrTypeInfo[] { - new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.FfiRequest), global::LiveKit.Proto.FfiRequest.Parser, new[]{ "Dispose", "Connect", "Disconnect", "PublishTrack", "UnpublishTrack", "PublishData", "SetSubscribed", "SetLocalMetadata", "SetLocalName", "SetLocalAttributes", "GetSessionStats", "PublishTranscription", "PublishSipDtmf", "CreateVideoTrack", "CreateAudioTrack", "LocalTrackMute", "EnableRemoteTrack", "GetStats", "NewVideoStream", "NewVideoSource", "CaptureVideoFrame", "VideoConvert", "VideoStreamFromParticipant", "NewAudioStream", "NewAudioSource", "CaptureAudioFrame", "ClearAudioBuffer", "NewAudioResampler", "RemixAndResample", "E2Ee", "AudioStreamFromParticipant", "NewSoxResampler", "PushSoxResampler", "FlushSoxResampler", "SendChatMessage", "EditChatMessage", "PerformRpc", "RegisterRpcMethod", "UnregisterRpcMethod", "RpcMethodInvocationResponse" }, new[]{ "Message" }, null, null, null), - new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.FfiResponse), global::LiveKit.Proto.FfiResponse.Parser, new[]{ "Dispose", "Connect", "Disconnect", "PublishTrack", "UnpublishTrack", "PublishData", "SetSubscribed", "SetLocalMetadata", "SetLocalName", "SetLocalAttributes", "GetSessionStats", "PublishTranscription", "PublishSipDtmf", "CreateVideoTrack", "CreateAudioTrack", "LocalTrackMute", "EnableRemoteTrack", "GetStats", "NewVideoStream", "NewVideoSource", "CaptureVideoFrame", "VideoConvert", "VideoStreamFromParticipant", "NewAudioStream", "NewAudioSource", "CaptureAudioFrame", "ClearAudioBuffer", "NewAudioResampler", "RemixAndResample", "AudioStreamFromParticipant", "E2Ee", "NewSoxResampler", "PushSoxResampler", "FlushSoxResampler", "SendChatMessage", "PerformRpc", "RegisterRpcMethod", "UnregisterRpcMethod", "RpcMethodInvocationResponse" }, new[]{ "Message" }, null, null, null), - new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.FfiEvent), global::LiveKit.Proto.FfiEvent.Parser, new[]{ "RoomEvent", "TrackEvent", "VideoStreamEvent", "AudioStreamEvent", "Connect", "Disconnect", "Dispose", "PublishTrack", "UnpublishTrack", "PublishData", "PublishTranscription", "CaptureAudioFrame", "SetLocalMetadata", "SetLocalName", "SetLocalAttributes", "GetStats", "Logs", "GetSessionStats", "Panic", "PublishSipDtmf", "ChatMessage", "PerformRpc", "RpcMethodInvocation" }, new[]{ "Message" }, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.FfiRequest), global::LiveKit.Proto.FfiRequest.Parser, new[]{ "Dispose", "Connect", "Disconnect", "PublishTrack", "UnpublishTrack", "PublishData", "SetSubscribed", "SetLocalMetadata", "SetLocalName", "SetLocalAttributes", "GetSessionStats", "PublishTranscription", "PublishSipDtmf", "CreateVideoTrack", "CreateAudioTrack", "LocalTrackMute", "EnableRemoteTrack", "GetStats", "SetTrackSubscriptionPermissions", "NewVideoStream", "NewVideoSource", "CaptureVideoFrame", "VideoConvert", "VideoStreamFromParticipant", "NewAudioStream", "NewAudioSource", "CaptureAudioFrame", "ClearAudioBuffer", "NewAudioResampler", "RemixAndResample", "E2Ee", "AudioStreamFromParticipant", "NewSoxResampler", "PushSoxResampler", "FlushSoxResampler", "SendChatMessage", "EditChatMessage", "PerformRpc", "RegisterRpcMethod", "UnregisterRpcMethod", "RpcMethodInvocationResponse", "EnableRemoteTrackPublication", "UpdateRemoteTrackPublicationDimension", "SendStreamHeader", "SendStreamChunk", "SendStreamTrailer", "SetDataChannelBufferedAmountLowThreshold", "LoadAudioFilterPlugin", "NewApm", "ApmProcessStream", "ApmProcessReverseStream", "ApmSetStreamDelay", "ByteReadIncremental", "ByteReadAll", "ByteWriteToFile", "TextReadIncremental", "TextReadAll", "SendFile", "SendText", "ByteStreamOpen", "ByteStreamWrite", "ByteStreamClose", "TextStreamOpen", "TextStreamWrite", "TextStreamClose" }, new[]{ "Message" }, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.FfiResponse), global::LiveKit.Proto.FfiResponse.Parser, new[]{ "Dispose", "Connect", "Disconnect", "PublishTrack", "UnpublishTrack", "PublishData", "SetSubscribed", "SetLocalMetadata", "SetLocalName", "SetLocalAttributes", "GetSessionStats", "PublishTranscription", "PublishSipDtmf", "CreateVideoTrack", "CreateAudioTrack", "LocalTrackMute", "EnableRemoteTrack", "GetStats", "SetTrackSubscriptionPermissions", "NewVideoStream", "NewVideoSource", "CaptureVideoFrame", "VideoConvert", "VideoStreamFromParticipant", "NewAudioStream", "NewAudioSource", "CaptureAudioFrame", "ClearAudioBuffer", "NewAudioResampler", "RemixAndResample", "AudioStreamFromParticipant", "E2Ee", "NewSoxResampler", "PushSoxResampler", "FlushSoxResampler", "SendChatMessage", "PerformRpc", "RegisterRpcMethod", "UnregisterRpcMethod", "RpcMethodInvocationResponse", "EnableRemoteTrackPublication", "UpdateRemoteTrackPublicationDimension", "SendStreamHeader", "SendStreamChunk", "SendStreamTrailer", "SetDataChannelBufferedAmountLowThreshold", "LoadAudioFilterPlugin", "NewApm", "ApmProcessStream", "ApmProcessReverseStream", "ApmSetStreamDelay", "ByteReadIncremental", "ByteReadAll", "ByteWriteToFile", "TextReadIncremental", "TextReadAll", "SendFile", "SendText", "ByteStreamOpen", "ByteStreamWrite", "ByteStreamClose", "TextStreamOpen", "TextStreamWrite", "TextStreamClose" }, new[]{ "Message" }, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.FfiEvent), global::LiveKit.Proto.FfiEvent.Parser, new[]{ "RoomEvent", "TrackEvent", "VideoStreamEvent", "AudioStreamEvent", "Connect", "Disconnect", "Dispose", "PublishTrack", "UnpublishTrack", "PublishData", "PublishTranscription", "CaptureAudioFrame", "SetLocalMetadata", "SetLocalName", "SetLocalAttributes", "GetStats", "Logs", "GetSessionStats", "Panic", "PublishSipDtmf", "ChatMessage", "PerformRpc", "RpcMethodInvocation", "SendStreamHeader", "SendStreamChunk", "SendStreamTrailer", "ByteStreamReaderEvent", "ByteStreamReaderReadAll", "ByteStreamReaderWriteToFile", "ByteStreamOpen", "ByteStreamWriterWrite", "ByteStreamWriterClose", "SendFile", "TextStreamReaderEvent", "TextStreamReaderReadAll", "TextStreamOpen", "TextStreamWriterWrite", "TextStreamWriterClose", "SendText" }, new[]{ "Message" }, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.DisposeRequest), global::LiveKit.Proto.DisposeRequest.Parser, new[]{ "Async" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.DisposeResponse), global::LiveKit.Proto.DisposeResponse.Parser, new[]{ "AsyncId" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.DisposeCallback), global::LiveKit.Proto.DisposeCallback.Parser, new[]{ "AsyncId" }, null, null, null, null), @@ -312,6 +427,9 @@ public FfiRequest(FfiRequest other) : this() { case MessageOneofCase.GetStats: GetStats = other.GetStats.Clone(); break; + case MessageOneofCase.SetTrackSubscriptionPermissions: + SetTrackSubscriptionPermissions = other.SetTrackSubscriptionPermissions.Clone(); + break; case MessageOneofCase.NewVideoStream: NewVideoStream = other.NewVideoStream.Clone(); break; @@ -378,6 +496,78 @@ public FfiRequest(FfiRequest other) : this() { case MessageOneofCase.RpcMethodInvocationResponse: RpcMethodInvocationResponse = other.RpcMethodInvocationResponse.Clone(); break; + case MessageOneofCase.EnableRemoteTrackPublication: + EnableRemoteTrackPublication = other.EnableRemoteTrackPublication.Clone(); + break; + case MessageOneofCase.UpdateRemoteTrackPublicationDimension: + UpdateRemoteTrackPublicationDimension = other.UpdateRemoteTrackPublicationDimension.Clone(); + break; + case MessageOneofCase.SendStreamHeader: + SendStreamHeader = other.SendStreamHeader.Clone(); + break; + case MessageOneofCase.SendStreamChunk: + SendStreamChunk = other.SendStreamChunk.Clone(); + break; + case MessageOneofCase.SendStreamTrailer: + SendStreamTrailer = other.SendStreamTrailer.Clone(); + break; + case MessageOneofCase.SetDataChannelBufferedAmountLowThreshold: + SetDataChannelBufferedAmountLowThreshold = other.SetDataChannelBufferedAmountLowThreshold.Clone(); + break; + case MessageOneofCase.LoadAudioFilterPlugin: + LoadAudioFilterPlugin = other.LoadAudioFilterPlugin.Clone(); + break; + case MessageOneofCase.NewApm: + NewApm = other.NewApm.Clone(); + break; + case MessageOneofCase.ApmProcessStream: + ApmProcessStream = other.ApmProcessStream.Clone(); + break; + case MessageOneofCase.ApmProcessReverseStream: + ApmProcessReverseStream = other.ApmProcessReverseStream.Clone(); + break; + case MessageOneofCase.ApmSetStreamDelay: + ApmSetStreamDelay = other.ApmSetStreamDelay.Clone(); + break; + case MessageOneofCase.ByteReadIncremental: + ByteReadIncremental = other.ByteReadIncremental.Clone(); + break; + case MessageOneofCase.ByteReadAll: + ByteReadAll = other.ByteReadAll.Clone(); + break; + case MessageOneofCase.ByteWriteToFile: + ByteWriteToFile = other.ByteWriteToFile.Clone(); + break; + case MessageOneofCase.TextReadIncremental: + TextReadIncremental = other.TextReadIncremental.Clone(); + break; + case MessageOneofCase.TextReadAll: + TextReadAll = other.TextReadAll.Clone(); + break; + case MessageOneofCase.SendFile: + SendFile = other.SendFile.Clone(); + break; + case MessageOneofCase.SendText: + SendText = other.SendText.Clone(); + break; + case MessageOneofCase.ByteStreamOpen: + ByteStreamOpen = other.ByteStreamOpen.Clone(); + break; + case MessageOneofCase.ByteStreamWrite: + ByteStreamWrite = other.ByteStreamWrite.Clone(); + break; + case MessageOneofCase.ByteStreamClose: + ByteStreamClose = other.ByteStreamClose.Clone(); + break; + case MessageOneofCase.TextStreamOpen: + TextStreamOpen = other.TextStreamOpen.Clone(); + break; + case MessageOneofCase.TextStreamWrite: + TextStreamWrite = other.TextStreamWrite.Clone(); + break; + case MessageOneofCase.TextStreamClose: + TextStreamClose = other.TextStreamClose.Clone(); + break; } _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); @@ -611,6 +801,18 @@ public FfiRequest Clone() { } } + /// Field number for the "set_track_subscription_permissions" field. + public const int SetTrackSubscriptionPermissionsFieldNumber = 48; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.SetTrackSubscriptionPermissionsRequest SetTrackSubscriptionPermissions { + get { return messageCase_ == MessageOneofCase.SetTrackSubscriptionPermissions ? (global::LiveKit.Proto.SetTrackSubscriptionPermissionsRequest) message_ : null; } + set { + message_ = value; + messageCase_ = value == null ? MessageOneofCase.None : MessageOneofCase.SetTrackSubscriptionPermissions; + } + } + /// Field number for the "new_video_stream" field. public const int NewVideoStreamFieldNumber = 20; /// @@ -884,6 +1086,309 @@ public FfiRequest Clone() { } } + /// Field number for the "enable_remote_track_publication" field. + public const int EnableRemoteTrackPublicationFieldNumber = 42; + /// + /// Track Publication + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.EnableRemoteTrackPublicationRequest EnableRemoteTrackPublication { + get { return messageCase_ == MessageOneofCase.EnableRemoteTrackPublication ? (global::LiveKit.Proto.EnableRemoteTrackPublicationRequest) message_ : null; } + set { + message_ = value; + messageCase_ = value == null ? MessageOneofCase.None : MessageOneofCase.EnableRemoteTrackPublication; + } + } + + /// Field number for the "update_remote_track_publication_dimension" field. + public const int UpdateRemoteTrackPublicationDimensionFieldNumber = 43; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.UpdateRemoteTrackPublicationDimensionRequest UpdateRemoteTrackPublicationDimension { + get { return messageCase_ == MessageOneofCase.UpdateRemoteTrackPublicationDimension ? (global::LiveKit.Proto.UpdateRemoteTrackPublicationDimensionRequest) message_ : null; } + set { + message_ = value; + messageCase_ = value == null ? MessageOneofCase.None : MessageOneofCase.UpdateRemoteTrackPublicationDimension; + } + } + + /// Field number for the "send_stream_header" field. + public const int SendStreamHeaderFieldNumber = 44; + /// + /// Data Streams (low level) + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.SendStreamHeaderRequest SendStreamHeader { + get { return messageCase_ == MessageOneofCase.SendStreamHeader ? (global::LiveKit.Proto.SendStreamHeaderRequest) message_ : null; } + set { + message_ = value; + messageCase_ = value == null ? MessageOneofCase.None : MessageOneofCase.SendStreamHeader; + } + } + + /// Field number for the "send_stream_chunk" field. + public const int SendStreamChunkFieldNumber = 45; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.SendStreamChunkRequest SendStreamChunk { + get { return messageCase_ == MessageOneofCase.SendStreamChunk ? (global::LiveKit.Proto.SendStreamChunkRequest) message_ : null; } + set { + message_ = value; + messageCase_ = value == null ? MessageOneofCase.None : MessageOneofCase.SendStreamChunk; + } + } + + /// Field number for the "send_stream_trailer" field. + public const int SendStreamTrailerFieldNumber = 46; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.SendStreamTrailerRequest SendStreamTrailer { + get { return messageCase_ == MessageOneofCase.SendStreamTrailer ? (global::LiveKit.Proto.SendStreamTrailerRequest) message_ : null; } + set { + message_ = value; + messageCase_ = value == null ? MessageOneofCase.None : MessageOneofCase.SendStreamTrailer; + } + } + + /// Field number for the "set_data_channel_buffered_amount_low_threshold" field. + public const int SetDataChannelBufferedAmountLowThresholdFieldNumber = 47; + /// + /// Data Channel + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.SetDataChannelBufferedAmountLowThresholdRequest SetDataChannelBufferedAmountLowThreshold { + get { return messageCase_ == MessageOneofCase.SetDataChannelBufferedAmountLowThreshold ? (global::LiveKit.Proto.SetDataChannelBufferedAmountLowThresholdRequest) message_ : null; } + set { + message_ = value; + messageCase_ = value == null ? MessageOneofCase.None : MessageOneofCase.SetDataChannelBufferedAmountLowThreshold; + } + } + + /// Field number for the "load_audio_filter_plugin" field. + public const int LoadAudioFilterPluginFieldNumber = 49; + /// + /// Audio Filter Plugin + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.LoadAudioFilterPluginRequest LoadAudioFilterPlugin { + get { return messageCase_ == MessageOneofCase.LoadAudioFilterPlugin ? (global::LiveKit.Proto.LoadAudioFilterPluginRequest) message_ : null; } + set { + message_ = value; + messageCase_ = value == null ? MessageOneofCase.None : MessageOneofCase.LoadAudioFilterPlugin; + } + } + + /// Field number for the "new_apm" field. + public const int NewApmFieldNumber = 50; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.NewApmRequest NewApm { + get { return messageCase_ == MessageOneofCase.NewApm ? (global::LiveKit.Proto.NewApmRequest) message_ : null; } + set { + message_ = value; + messageCase_ = value == null ? MessageOneofCase.None : MessageOneofCase.NewApm; + } + } + + /// Field number for the "apm_process_stream" field. + public const int ApmProcessStreamFieldNumber = 51; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.ApmProcessStreamRequest ApmProcessStream { + get { return messageCase_ == MessageOneofCase.ApmProcessStream ? (global::LiveKit.Proto.ApmProcessStreamRequest) message_ : null; } + set { + message_ = value; + messageCase_ = value == null ? MessageOneofCase.None : MessageOneofCase.ApmProcessStream; + } + } + + /// Field number for the "apm_process_reverse_stream" field. + public const int ApmProcessReverseStreamFieldNumber = 52; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.ApmProcessReverseStreamRequest ApmProcessReverseStream { + get { return messageCase_ == MessageOneofCase.ApmProcessReverseStream ? (global::LiveKit.Proto.ApmProcessReverseStreamRequest) message_ : null; } + set { + message_ = value; + messageCase_ = value == null ? MessageOneofCase.None : MessageOneofCase.ApmProcessReverseStream; + } + } + + /// Field number for the "apm_set_stream_delay" field. + public const int ApmSetStreamDelayFieldNumber = 53; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.ApmSetStreamDelayRequest ApmSetStreamDelay { + get { return messageCase_ == MessageOneofCase.ApmSetStreamDelay ? (global::LiveKit.Proto.ApmSetStreamDelayRequest) message_ : null; } + set { + message_ = value; + messageCase_ = value == null ? MessageOneofCase.None : MessageOneofCase.ApmSetStreamDelay; + } + } + + /// Field number for the "byte_read_incremental" field. + public const int ByteReadIncrementalFieldNumber = 54; + /// + /// Data Streams (high level) + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.ByteStreamReaderReadIncrementalRequest ByteReadIncremental { + get { return messageCase_ == MessageOneofCase.ByteReadIncremental ? (global::LiveKit.Proto.ByteStreamReaderReadIncrementalRequest) message_ : null; } + set { + message_ = value; + messageCase_ = value == null ? MessageOneofCase.None : MessageOneofCase.ByteReadIncremental; + } + } + + /// Field number for the "byte_read_all" field. + public const int ByteReadAllFieldNumber = 55; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.ByteStreamReaderReadAllRequest ByteReadAll { + get { return messageCase_ == MessageOneofCase.ByteReadAll ? (global::LiveKit.Proto.ByteStreamReaderReadAllRequest) message_ : null; } + set { + message_ = value; + messageCase_ = value == null ? MessageOneofCase.None : MessageOneofCase.ByteReadAll; + } + } + + /// Field number for the "byte_write_to_file" field. + public const int ByteWriteToFileFieldNumber = 56; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.ByteStreamReaderWriteToFileRequest ByteWriteToFile { + get { return messageCase_ == MessageOneofCase.ByteWriteToFile ? (global::LiveKit.Proto.ByteStreamReaderWriteToFileRequest) message_ : null; } + set { + message_ = value; + messageCase_ = value == null ? MessageOneofCase.None : MessageOneofCase.ByteWriteToFile; + } + } + + /// Field number for the "text_read_incremental" field. + public const int TextReadIncrementalFieldNumber = 57; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.TextStreamReaderReadIncrementalRequest TextReadIncremental { + get { return messageCase_ == MessageOneofCase.TextReadIncremental ? (global::LiveKit.Proto.TextStreamReaderReadIncrementalRequest) message_ : null; } + set { + message_ = value; + messageCase_ = value == null ? MessageOneofCase.None : MessageOneofCase.TextReadIncremental; + } + } + + /// Field number for the "text_read_all" field. + public const int TextReadAllFieldNumber = 58; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.TextStreamReaderReadAllRequest TextReadAll { + get { return messageCase_ == MessageOneofCase.TextReadAll ? (global::LiveKit.Proto.TextStreamReaderReadAllRequest) message_ : null; } + set { + message_ = value; + messageCase_ = value == null ? MessageOneofCase.None : MessageOneofCase.TextReadAll; + } + } + + /// Field number for the "send_file" field. + public const int SendFileFieldNumber = 59; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.StreamSendFileRequest SendFile { + get { return messageCase_ == MessageOneofCase.SendFile ? (global::LiveKit.Proto.StreamSendFileRequest) message_ : null; } + set { + message_ = value; + messageCase_ = value == null ? MessageOneofCase.None : MessageOneofCase.SendFile; + } + } + + /// Field number for the "send_text" field. + public const int SendTextFieldNumber = 60; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.StreamSendTextRequest SendText { + get { return messageCase_ == MessageOneofCase.SendText ? (global::LiveKit.Proto.StreamSendTextRequest) message_ : null; } + set { + message_ = value; + messageCase_ = value == null ? MessageOneofCase.None : MessageOneofCase.SendText; + } + } + + /// Field number for the "byte_stream_open" field. + public const int ByteStreamOpenFieldNumber = 61; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.ByteStreamOpenRequest ByteStreamOpen { + get { return messageCase_ == MessageOneofCase.ByteStreamOpen ? (global::LiveKit.Proto.ByteStreamOpenRequest) message_ : null; } + set { + message_ = value; + messageCase_ = value == null ? MessageOneofCase.None : MessageOneofCase.ByteStreamOpen; + } + } + + /// Field number for the "byte_stream_write" field. + public const int ByteStreamWriteFieldNumber = 62; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.ByteStreamWriterWriteRequest ByteStreamWrite { + get { return messageCase_ == MessageOneofCase.ByteStreamWrite ? (global::LiveKit.Proto.ByteStreamWriterWriteRequest) message_ : null; } + set { + message_ = value; + messageCase_ = value == null ? MessageOneofCase.None : MessageOneofCase.ByteStreamWrite; + } + } + + /// Field number for the "byte_stream_close" field. + public const int ByteStreamCloseFieldNumber = 63; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.ByteStreamWriterCloseRequest ByteStreamClose { + get { return messageCase_ == MessageOneofCase.ByteStreamClose ? (global::LiveKit.Proto.ByteStreamWriterCloseRequest) message_ : null; } + set { + message_ = value; + messageCase_ = value == null ? MessageOneofCase.None : MessageOneofCase.ByteStreamClose; + } + } + + /// Field number for the "text_stream_open" field. + public const int TextStreamOpenFieldNumber = 64; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.TextStreamOpenRequest TextStreamOpen { + get { return messageCase_ == MessageOneofCase.TextStreamOpen ? (global::LiveKit.Proto.TextStreamOpenRequest) message_ : null; } + set { + message_ = value; + messageCase_ = value == null ? MessageOneofCase.None : MessageOneofCase.TextStreamOpen; + } + } + + /// Field number for the "text_stream_write" field. + public const int TextStreamWriteFieldNumber = 65; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.TextStreamWriterWriteRequest TextStreamWrite { + get { return messageCase_ == MessageOneofCase.TextStreamWrite ? (global::LiveKit.Proto.TextStreamWriterWriteRequest) message_ : null; } + set { + message_ = value; + messageCase_ = value == null ? MessageOneofCase.None : MessageOneofCase.TextStreamWrite; + } + } + + /// Field number for the "text_stream_close" field. + public const int TextStreamCloseFieldNumber = 66; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.TextStreamWriterCloseRequest TextStreamClose { + get { return messageCase_ == MessageOneofCase.TextStreamClose ? (global::LiveKit.Proto.TextStreamWriterCloseRequest) message_ : null; } + set { + message_ = value; + messageCase_ = value == null ? MessageOneofCase.None : MessageOneofCase.TextStreamClose; + } + } + private object message_; /// Enum of possible cases for the "message" oneof. public enum MessageOneofCase { @@ -906,6 +1411,7 @@ public enum MessageOneofCase { LocalTrackMute = 17, EnableRemoteTrack = 18, GetStats = 19, + SetTrackSubscriptionPermissions = 48, NewVideoStream = 20, NewVideoSource = 21, CaptureVideoFrame = 22, @@ -928,6 +1434,30 @@ public enum MessageOneofCase { RegisterRpcMethod = 39, UnregisterRpcMethod = 40, RpcMethodInvocationResponse = 41, + EnableRemoteTrackPublication = 42, + UpdateRemoteTrackPublicationDimension = 43, + SendStreamHeader = 44, + SendStreamChunk = 45, + SendStreamTrailer = 46, + SetDataChannelBufferedAmountLowThreshold = 47, + LoadAudioFilterPlugin = 49, + NewApm = 50, + ApmProcessStream = 51, + ApmProcessReverseStream = 52, + ApmSetStreamDelay = 53, + ByteReadIncremental = 54, + ByteReadAll = 55, + ByteWriteToFile = 56, + TextReadIncremental = 57, + TextReadAll = 58, + SendFile = 59, + SendText = 60, + ByteStreamOpen = 61, + ByteStreamWrite = 62, + ByteStreamClose = 63, + TextStreamOpen = 64, + TextStreamWrite = 65, + TextStreamClose = 66, } private MessageOneofCase messageCase_ = MessageOneofCase.None; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -976,6 +1506,7 @@ public bool Equals(FfiRequest other) { if (!object.Equals(LocalTrackMute, other.LocalTrackMute)) return false; if (!object.Equals(EnableRemoteTrack, other.EnableRemoteTrack)) return false; if (!object.Equals(GetStats, other.GetStats)) return false; + if (!object.Equals(SetTrackSubscriptionPermissions, other.SetTrackSubscriptionPermissions)) return false; if (!object.Equals(NewVideoStream, other.NewVideoStream)) return false; if (!object.Equals(NewVideoSource, other.NewVideoSource)) return false; if (!object.Equals(CaptureVideoFrame, other.CaptureVideoFrame)) return false; @@ -998,6 +1529,30 @@ public bool Equals(FfiRequest other) { if (!object.Equals(RegisterRpcMethod, other.RegisterRpcMethod)) return false; if (!object.Equals(UnregisterRpcMethod, other.UnregisterRpcMethod)) return false; if (!object.Equals(RpcMethodInvocationResponse, other.RpcMethodInvocationResponse)) return false; + if (!object.Equals(EnableRemoteTrackPublication, other.EnableRemoteTrackPublication)) return false; + if (!object.Equals(UpdateRemoteTrackPublicationDimension, other.UpdateRemoteTrackPublicationDimension)) return false; + if (!object.Equals(SendStreamHeader, other.SendStreamHeader)) return false; + if (!object.Equals(SendStreamChunk, other.SendStreamChunk)) return false; + if (!object.Equals(SendStreamTrailer, other.SendStreamTrailer)) return false; + if (!object.Equals(SetDataChannelBufferedAmountLowThreshold, other.SetDataChannelBufferedAmountLowThreshold)) return false; + if (!object.Equals(LoadAudioFilterPlugin, other.LoadAudioFilterPlugin)) return false; + if (!object.Equals(NewApm, other.NewApm)) return false; + if (!object.Equals(ApmProcessStream, other.ApmProcessStream)) return false; + if (!object.Equals(ApmProcessReverseStream, other.ApmProcessReverseStream)) return false; + if (!object.Equals(ApmSetStreamDelay, other.ApmSetStreamDelay)) return false; + if (!object.Equals(ByteReadIncremental, other.ByteReadIncremental)) return false; + if (!object.Equals(ByteReadAll, other.ByteReadAll)) return false; + if (!object.Equals(ByteWriteToFile, other.ByteWriteToFile)) return false; + if (!object.Equals(TextReadIncremental, other.TextReadIncremental)) return false; + if (!object.Equals(TextReadAll, other.TextReadAll)) return false; + if (!object.Equals(SendFile, other.SendFile)) return false; + if (!object.Equals(SendText, other.SendText)) return false; + if (!object.Equals(ByteStreamOpen, other.ByteStreamOpen)) return false; + if (!object.Equals(ByteStreamWrite, other.ByteStreamWrite)) return false; + if (!object.Equals(ByteStreamClose, other.ByteStreamClose)) return false; + if (!object.Equals(TextStreamOpen, other.TextStreamOpen)) return false; + if (!object.Equals(TextStreamWrite, other.TextStreamWrite)) return false; + if (!object.Equals(TextStreamClose, other.TextStreamClose)) return false; if (MessageCase != other.MessageCase) return false; return Equals(_unknownFields, other._unknownFields); } @@ -1024,6 +1579,7 @@ public override int GetHashCode() { if (messageCase_ == MessageOneofCase.LocalTrackMute) hash ^= LocalTrackMute.GetHashCode(); if (messageCase_ == MessageOneofCase.EnableRemoteTrack) hash ^= EnableRemoteTrack.GetHashCode(); if (messageCase_ == MessageOneofCase.GetStats) hash ^= GetStats.GetHashCode(); + if (messageCase_ == MessageOneofCase.SetTrackSubscriptionPermissions) hash ^= SetTrackSubscriptionPermissions.GetHashCode(); if (messageCase_ == MessageOneofCase.NewVideoStream) hash ^= NewVideoStream.GetHashCode(); if (messageCase_ == MessageOneofCase.NewVideoSource) hash ^= NewVideoSource.GetHashCode(); if (messageCase_ == MessageOneofCase.CaptureVideoFrame) hash ^= CaptureVideoFrame.GetHashCode(); @@ -1046,6 +1602,30 @@ public override int GetHashCode() { if (messageCase_ == MessageOneofCase.RegisterRpcMethod) hash ^= RegisterRpcMethod.GetHashCode(); if (messageCase_ == MessageOneofCase.UnregisterRpcMethod) hash ^= UnregisterRpcMethod.GetHashCode(); if (messageCase_ == MessageOneofCase.RpcMethodInvocationResponse) hash ^= RpcMethodInvocationResponse.GetHashCode(); + if (messageCase_ == MessageOneofCase.EnableRemoteTrackPublication) hash ^= EnableRemoteTrackPublication.GetHashCode(); + if (messageCase_ == MessageOneofCase.UpdateRemoteTrackPublicationDimension) hash ^= UpdateRemoteTrackPublicationDimension.GetHashCode(); + if (messageCase_ == MessageOneofCase.SendStreamHeader) hash ^= SendStreamHeader.GetHashCode(); + if (messageCase_ == MessageOneofCase.SendStreamChunk) hash ^= SendStreamChunk.GetHashCode(); + if (messageCase_ == MessageOneofCase.SendStreamTrailer) hash ^= SendStreamTrailer.GetHashCode(); + if (messageCase_ == MessageOneofCase.SetDataChannelBufferedAmountLowThreshold) hash ^= SetDataChannelBufferedAmountLowThreshold.GetHashCode(); + if (messageCase_ == MessageOneofCase.LoadAudioFilterPlugin) hash ^= LoadAudioFilterPlugin.GetHashCode(); + if (messageCase_ == MessageOneofCase.NewApm) hash ^= NewApm.GetHashCode(); + if (messageCase_ == MessageOneofCase.ApmProcessStream) hash ^= ApmProcessStream.GetHashCode(); + if (messageCase_ == MessageOneofCase.ApmProcessReverseStream) hash ^= ApmProcessReverseStream.GetHashCode(); + if (messageCase_ == MessageOneofCase.ApmSetStreamDelay) hash ^= ApmSetStreamDelay.GetHashCode(); + if (messageCase_ == MessageOneofCase.ByteReadIncremental) hash ^= ByteReadIncremental.GetHashCode(); + if (messageCase_ == MessageOneofCase.ByteReadAll) hash ^= ByteReadAll.GetHashCode(); + if (messageCase_ == MessageOneofCase.ByteWriteToFile) hash ^= ByteWriteToFile.GetHashCode(); + if (messageCase_ == MessageOneofCase.TextReadIncremental) hash ^= TextReadIncremental.GetHashCode(); + if (messageCase_ == MessageOneofCase.TextReadAll) hash ^= TextReadAll.GetHashCode(); + if (messageCase_ == MessageOneofCase.SendFile) hash ^= SendFile.GetHashCode(); + if (messageCase_ == MessageOneofCase.SendText) hash ^= SendText.GetHashCode(); + if (messageCase_ == MessageOneofCase.ByteStreamOpen) hash ^= ByteStreamOpen.GetHashCode(); + if (messageCase_ == MessageOneofCase.ByteStreamWrite) hash ^= ByteStreamWrite.GetHashCode(); + if (messageCase_ == MessageOneofCase.ByteStreamClose) hash ^= ByteStreamClose.GetHashCode(); + if (messageCase_ == MessageOneofCase.TextStreamOpen) hash ^= TextStreamOpen.GetHashCode(); + if (messageCase_ == MessageOneofCase.TextStreamWrite) hash ^= TextStreamWrite.GetHashCode(); + if (messageCase_ == MessageOneofCase.TextStreamClose) hash ^= TextStreamClose.GetHashCode(); hash ^= (int) messageCase_; if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); @@ -1225,6 +1805,106 @@ public void WriteTo(pb::CodedOutputStream output) { output.WriteRawTag(202, 2); output.WriteMessage(RpcMethodInvocationResponse); } + if (messageCase_ == MessageOneofCase.EnableRemoteTrackPublication) { + output.WriteRawTag(210, 2); + output.WriteMessage(EnableRemoteTrackPublication); + } + if (messageCase_ == MessageOneofCase.UpdateRemoteTrackPublicationDimension) { + output.WriteRawTag(218, 2); + output.WriteMessage(UpdateRemoteTrackPublicationDimension); + } + if (messageCase_ == MessageOneofCase.SendStreamHeader) { + output.WriteRawTag(226, 2); + output.WriteMessage(SendStreamHeader); + } + if (messageCase_ == MessageOneofCase.SendStreamChunk) { + output.WriteRawTag(234, 2); + output.WriteMessage(SendStreamChunk); + } + if (messageCase_ == MessageOneofCase.SendStreamTrailer) { + output.WriteRawTag(242, 2); + output.WriteMessage(SendStreamTrailer); + } + if (messageCase_ == MessageOneofCase.SetDataChannelBufferedAmountLowThreshold) { + output.WriteRawTag(250, 2); + output.WriteMessage(SetDataChannelBufferedAmountLowThreshold); + } + if (messageCase_ == MessageOneofCase.SetTrackSubscriptionPermissions) { + output.WriteRawTag(130, 3); + output.WriteMessage(SetTrackSubscriptionPermissions); + } + if (messageCase_ == MessageOneofCase.LoadAudioFilterPlugin) { + output.WriteRawTag(138, 3); + output.WriteMessage(LoadAudioFilterPlugin); + } + if (messageCase_ == MessageOneofCase.NewApm) { + output.WriteRawTag(146, 3); + output.WriteMessage(NewApm); + } + if (messageCase_ == MessageOneofCase.ApmProcessStream) { + output.WriteRawTag(154, 3); + output.WriteMessage(ApmProcessStream); + } + if (messageCase_ == MessageOneofCase.ApmProcessReverseStream) { + output.WriteRawTag(162, 3); + output.WriteMessage(ApmProcessReverseStream); + } + if (messageCase_ == MessageOneofCase.ApmSetStreamDelay) { + output.WriteRawTag(170, 3); + output.WriteMessage(ApmSetStreamDelay); + } + if (messageCase_ == MessageOneofCase.ByteReadIncremental) { + output.WriteRawTag(178, 3); + output.WriteMessage(ByteReadIncremental); + } + if (messageCase_ == MessageOneofCase.ByteReadAll) { + output.WriteRawTag(186, 3); + output.WriteMessage(ByteReadAll); + } + if (messageCase_ == MessageOneofCase.ByteWriteToFile) { + output.WriteRawTag(194, 3); + output.WriteMessage(ByteWriteToFile); + } + if (messageCase_ == MessageOneofCase.TextReadIncremental) { + output.WriteRawTag(202, 3); + output.WriteMessage(TextReadIncremental); + } + if (messageCase_ == MessageOneofCase.TextReadAll) { + output.WriteRawTag(210, 3); + output.WriteMessage(TextReadAll); + } + if (messageCase_ == MessageOneofCase.SendFile) { + output.WriteRawTag(218, 3); + output.WriteMessage(SendFile); + } + if (messageCase_ == MessageOneofCase.SendText) { + output.WriteRawTag(226, 3); + output.WriteMessage(SendText); + } + if (messageCase_ == MessageOneofCase.ByteStreamOpen) { + output.WriteRawTag(234, 3); + output.WriteMessage(ByteStreamOpen); + } + if (messageCase_ == MessageOneofCase.ByteStreamWrite) { + output.WriteRawTag(242, 3); + output.WriteMessage(ByteStreamWrite); + } + if (messageCase_ == MessageOneofCase.ByteStreamClose) { + output.WriteRawTag(250, 3); + output.WriteMessage(ByteStreamClose); + } + if (messageCase_ == MessageOneofCase.TextStreamOpen) { + output.WriteRawTag(130, 4); + output.WriteMessage(TextStreamOpen); + } + if (messageCase_ == MessageOneofCase.TextStreamWrite) { + output.WriteRawTag(138, 4); + output.WriteMessage(TextStreamWrite); + } + if (messageCase_ == MessageOneofCase.TextStreamClose) { + output.WriteRawTag(146, 4); + output.WriteMessage(TextStreamClose); + } if (_unknownFields != null) { _unknownFields.WriteTo(output); } @@ -1395,33 +2075,133 @@ public void WriteTo(pb::CodedOutputStream output) { output.WriteRawTag(202, 2); output.WriteMessage(RpcMethodInvocationResponse); } - if (_unknownFields != null) { - _unknownFields.WriteTo(ref output); + if (messageCase_ == MessageOneofCase.EnableRemoteTrackPublication) { + output.WriteRawTag(210, 2); + output.WriteMessage(EnableRemoteTrackPublication); } - } - #endif - - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public int CalculateSize() { - int size = 0; - if (messageCase_ == MessageOneofCase.Dispose) { - size += 1 + pb::CodedOutputStream.ComputeMessageSize(Dispose); + if (messageCase_ == MessageOneofCase.UpdateRemoteTrackPublicationDimension) { + output.WriteRawTag(218, 2); + output.WriteMessage(UpdateRemoteTrackPublicationDimension); } - if (messageCase_ == MessageOneofCase.Connect) { - size += 1 + pb::CodedOutputStream.ComputeMessageSize(Connect); + if (messageCase_ == MessageOneofCase.SendStreamHeader) { + output.WriteRawTag(226, 2); + output.WriteMessage(SendStreamHeader); } - if (messageCase_ == MessageOneofCase.Disconnect) { - size += 1 + pb::CodedOutputStream.ComputeMessageSize(Disconnect); + if (messageCase_ == MessageOneofCase.SendStreamChunk) { + output.WriteRawTag(234, 2); + output.WriteMessage(SendStreamChunk); } - if (messageCase_ == MessageOneofCase.PublishTrack) { - size += 1 + pb::CodedOutputStream.ComputeMessageSize(PublishTrack); + if (messageCase_ == MessageOneofCase.SendStreamTrailer) { + output.WriteRawTag(242, 2); + output.WriteMessage(SendStreamTrailer); } - if (messageCase_ == MessageOneofCase.UnpublishTrack) { - size += 1 + pb::CodedOutputStream.ComputeMessageSize(UnpublishTrack); + if (messageCase_ == MessageOneofCase.SetDataChannelBufferedAmountLowThreshold) { + output.WriteRawTag(250, 2); + output.WriteMessage(SetDataChannelBufferedAmountLowThreshold); } - if (messageCase_ == MessageOneofCase.PublishData) { - size += 1 + pb::CodedOutputStream.ComputeMessageSize(PublishData); + if (messageCase_ == MessageOneofCase.SetTrackSubscriptionPermissions) { + output.WriteRawTag(130, 3); + output.WriteMessage(SetTrackSubscriptionPermissions); + } + if (messageCase_ == MessageOneofCase.LoadAudioFilterPlugin) { + output.WriteRawTag(138, 3); + output.WriteMessage(LoadAudioFilterPlugin); + } + if (messageCase_ == MessageOneofCase.NewApm) { + output.WriteRawTag(146, 3); + output.WriteMessage(NewApm); + } + if (messageCase_ == MessageOneofCase.ApmProcessStream) { + output.WriteRawTag(154, 3); + output.WriteMessage(ApmProcessStream); + } + if (messageCase_ == MessageOneofCase.ApmProcessReverseStream) { + output.WriteRawTag(162, 3); + output.WriteMessage(ApmProcessReverseStream); + } + if (messageCase_ == MessageOneofCase.ApmSetStreamDelay) { + output.WriteRawTag(170, 3); + output.WriteMessage(ApmSetStreamDelay); + } + if (messageCase_ == MessageOneofCase.ByteReadIncremental) { + output.WriteRawTag(178, 3); + output.WriteMessage(ByteReadIncremental); + } + if (messageCase_ == MessageOneofCase.ByteReadAll) { + output.WriteRawTag(186, 3); + output.WriteMessage(ByteReadAll); + } + if (messageCase_ == MessageOneofCase.ByteWriteToFile) { + output.WriteRawTag(194, 3); + output.WriteMessage(ByteWriteToFile); + } + if (messageCase_ == MessageOneofCase.TextReadIncremental) { + output.WriteRawTag(202, 3); + output.WriteMessage(TextReadIncremental); + } + if (messageCase_ == MessageOneofCase.TextReadAll) { + output.WriteRawTag(210, 3); + output.WriteMessage(TextReadAll); + } + if (messageCase_ == MessageOneofCase.SendFile) { + output.WriteRawTag(218, 3); + output.WriteMessage(SendFile); + } + if (messageCase_ == MessageOneofCase.SendText) { + output.WriteRawTag(226, 3); + output.WriteMessage(SendText); + } + if (messageCase_ == MessageOneofCase.ByteStreamOpen) { + output.WriteRawTag(234, 3); + output.WriteMessage(ByteStreamOpen); + } + if (messageCase_ == MessageOneofCase.ByteStreamWrite) { + output.WriteRawTag(242, 3); + output.WriteMessage(ByteStreamWrite); + } + if (messageCase_ == MessageOneofCase.ByteStreamClose) { + output.WriteRawTag(250, 3); + output.WriteMessage(ByteStreamClose); + } + if (messageCase_ == MessageOneofCase.TextStreamOpen) { + output.WriteRawTag(130, 4); + output.WriteMessage(TextStreamOpen); + } + if (messageCase_ == MessageOneofCase.TextStreamWrite) { + output.WriteRawTag(138, 4); + output.WriteMessage(TextStreamWrite); + } + if (messageCase_ == MessageOneofCase.TextStreamClose) { + output.WriteRawTag(146, 4); + output.WriteMessage(TextStreamClose); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (messageCase_ == MessageOneofCase.Dispose) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Dispose); + } + if (messageCase_ == MessageOneofCase.Connect) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Connect); + } + if (messageCase_ == MessageOneofCase.Disconnect) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Disconnect); + } + if (messageCase_ == MessageOneofCase.PublishTrack) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(PublishTrack); + } + if (messageCase_ == MessageOneofCase.UnpublishTrack) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(UnpublishTrack); + } + if (messageCase_ == MessageOneofCase.PublishData) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(PublishData); } if (messageCase_ == MessageOneofCase.SetSubscribed) { size += 1 + pb::CodedOutputStream.ComputeMessageSize(SetSubscribed); @@ -1459,6 +2239,9 @@ public int CalculateSize() { if (messageCase_ == MessageOneofCase.GetStats) { size += 2 + pb::CodedOutputStream.ComputeMessageSize(GetStats); } + if (messageCase_ == MessageOneofCase.SetTrackSubscriptionPermissions) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(SetTrackSubscriptionPermissions); + } if (messageCase_ == MessageOneofCase.NewVideoStream) { size += 2 + pb::CodedOutputStream.ComputeMessageSize(NewVideoStream); } @@ -1525,6 +2308,78 @@ public int CalculateSize() { if (messageCase_ == MessageOneofCase.RpcMethodInvocationResponse) { size += 2 + pb::CodedOutputStream.ComputeMessageSize(RpcMethodInvocationResponse); } + if (messageCase_ == MessageOneofCase.EnableRemoteTrackPublication) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(EnableRemoteTrackPublication); + } + if (messageCase_ == MessageOneofCase.UpdateRemoteTrackPublicationDimension) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(UpdateRemoteTrackPublicationDimension); + } + if (messageCase_ == MessageOneofCase.SendStreamHeader) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(SendStreamHeader); + } + if (messageCase_ == MessageOneofCase.SendStreamChunk) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(SendStreamChunk); + } + if (messageCase_ == MessageOneofCase.SendStreamTrailer) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(SendStreamTrailer); + } + if (messageCase_ == MessageOneofCase.SetDataChannelBufferedAmountLowThreshold) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(SetDataChannelBufferedAmountLowThreshold); + } + if (messageCase_ == MessageOneofCase.LoadAudioFilterPlugin) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(LoadAudioFilterPlugin); + } + if (messageCase_ == MessageOneofCase.NewApm) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(NewApm); + } + if (messageCase_ == MessageOneofCase.ApmProcessStream) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(ApmProcessStream); + } + if (messageCase_ == MessageOneofCase.ApmProcessReverseStream) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(ApmProcessReverseStream); + } + if (messageCase_ == MessageOneofCase.ApmSetStreamDelay) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(ApmSetStreamDelay); + } + if (messageCase_ == MessageOneofCase.ByteReadIncremental) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(ByteReadIncremental); + } + if (messageCase_ == MessageOneofCase.ByteReadAll) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(ByteReadAll); + } + if (messageCase_ == MessageOneofCase.ByteWriteToFile) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(ByteWriteToFile); + } + if (messageCase_ == MessageOneofCase.TextReadIncremental) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(TextReadIncremental); + } + if (messageCase_ == MessageOneofCase.TextReadAll) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(TextReadAll); + } + if (messageCase_ == MessageOneofCase.SendFile) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(SendFile); + } + if (messageCase_ == MessageOneofCase.SendText) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(SendText); + } + if (messageCase_ == MessageOneofCase.ByteStreamOpen) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(ByteStreamOpen); + } + if (messageCase_ == MessageOneofCase.ByteStreamWrite) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(ByteStreamWrite); + } + if (messageCase_ == MessageOneofCase.ByteStreamClose) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(ByteStreamClose); + } + if (messageCase_ == MessageOneofCase.TextStreamOpen) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(TextStreamOpen); + } + if (messageCase_ == MessageOneofCase.TextStreamWrite) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(TextStreamWrite); + } + if (messageCase_ == MessageOneofCase.TextStreamClose) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(TextStreamClose); + } if (_unknownFields != null) { size += _unknownFields.CalculateSize(); } @@ -1646,6 +2501,12 @@ public void MergeFrom(FfiRequest other) { } GetStats.MergeFrom(other.GetStats); break; + case MessageOneofCase.SetTrackSubscriptionPermissions: + if (SetTrackSubscriptionPermissions == null) { + SetTrackSubscriptionPermissions = new global::LiveKit.Proto.SetTrackSubscriptionPermissionsRequest(); + } + SetTrackSubscriptionPermissions.MergeFrom(other.SetTrackSubscriptionPermissions); + break; case MessageOneofCase.NewVideoStream: if (NewVideoStream == null) { NewVideoStream = new global::LiveKit.Proto.NewVideoStreamRequest(); @@ -1778,6 +2639,150 @@ public void MergeFrom(FfiRequest other) { } RpcMethodInvocationResponse.MergeFrom(other.RpcMethodInvocationResponse); break; + case MessageOneofCase.EnableRemoteTrackPublication: + if (EnableRemoteTrackPublication == null) { + EnableRemoteTrackPublication = new global::LiveKit.Proto.EnableRemoteTrackPublicationRequest(); + } + EnableRemoteTrackPublication.MergeFrom(other.EnableRemoteTrackPublication); + break; + case MessageOneofCase.UpdateRemoteTrackPublicationDimension: + if (UpdateRemoteTrackPublicationDimension == null) { + UpdateRemoteTrackPublicationDimension = new global::LiveKit.Proto.UpdateRemoteTrackPublicationDimensionRequest(); + } + UpdateRemoteTrackPublicationDimension.MergeFrom(other.UpdateRemoteTrackPublicationDimension); + break; + case MessageOneofCase.SendStreamHeader: + if (SendStreamHeader == null) { + SendStreamHeader = new global::LiveKit.Proto.SendStreamHeaderRequest(); + } + SendStreamHeader.MergeFrom(other.SendStreamHeader); + break; + case MessageOneofCase.SendStreamChunk: + if (SendStreamChunk == null) { + SendStreamChunk = new global::LiveKit.Proto.SendStreamChunkRequest(); + } + SendStreamChunk.MergeFrom(other.SendStreamChunk); + break; + case MessageOneofCase.SendStreamTrailer: + if (SendStreamTrailer == null) { + SendStreamTrailer = new global::LiveKit.Proto.SendStreamTrailerRequest(); + } + SendStreamTrailer.MergeFrom(other.SendStreamTrailer); + break; + case MessageOneofCase.SetDataChannelBufferedAmountLowThreshold: + if (SetDataChannelBufferedAmountLowThreshold == null) { + SetDataChannelBufferedAmountLowThreshold = new global::LiveKit.Proto.SetDataChannelBufferedAmountLowThresholdRequest(); + } + SetDataChannelBufferedAmountLowThreshold.MergeFrom(other.SetDataChannelBufferedAmountLowThreshold); + break; + case MessageOneofCase.LoadAudioFilterPlugin: + if (LoadAudioFilterPlugin == null) { + LoadAudioFilterPlugin = new global::LiveKit.Proto.LoadAudioFilterPluginRequest(); + } + LoadAudioFilterPlugin.MergeFrom(other.LoadAudioFilterPlugin); + break; + case MessageOneofCase.NewApm: + if (NewApm == null) { + NewApm = new global::LiveKit.Proto.NewApmRequest(); + } + NewApm.MergeFrom(other.NewApm); + break; + case MessageOneofCase.ApmProcessStream: + if (ApmProcessStream == null) { + ApmProcessStream = new global::LiveKit.Proto.ApmProcessStreamRequest(); + } + ApmProcessStream.MergeFrom(other.ApmProcessStream); + break; + case MessageOneofCase.ApmProcessReverseStream: + if (ApmProcessReverseStream == null) { + ApmProcessReverseStream = new global::LiveKit.Proto.ApmProcessReverseStreamRequest(); + } + ApmProcessReverseStream.MergeFrom(other.ApmProcessReverseStream); + break; + case MessageOneofCase.ApmSetStreamDelay: + if (ApmSetStreamDelay == null) { + ApmSetStreamDelay = new global::LiveKit.Proto.ApmSetStreamDelayRequest(); + } + ApmSetStreamDelay.MergeFrom(other.ApmSetStreamDelay); + break; + case MessageOneofCase.ByteReadIncremental: + if (ByteReadIncremental == null) { + ByteReadIncremental = new global::LiveKit.Proto.ByteStreamReaderReadIncrementalRequest(); + } + ByteReadIncremental.MergeFrom(other.ByteReadIncremental); + break; + case MessageOneofCase.ByteReadAll: + if (ByteReadAll == null) { + ByteReadAll = new global::LiveKit.Proto.ByteStreamReaderReadAllRequest(); + } + ByteReadAll.MergeFrom(other.ByteReadAll); + break; + case MessageOneofCase.ByteWriteToFile: + if (ByteWriteToFile == null) { + ByteWriteToFile = new global::LiveKit.Proto.ByteStreamReaderWriteToFileRequest(); + } + ByteWriteToFile.MergeFrom(other.ByteWriteToFile); + break; + case MessageOneofCase.TextReadIncremental: + if (TextReadIncremental == null) { + TextReadIncremental = new global::LiveKit.Proto.TextStreamReaderReadIncrementalRequest(); + } + TextReadIncremental.MergeFrom(other.TextReadIncremental); + break; + case MessageOneofCase.TextReadAll: + if (TextReadAll == null) { + TextReadAll = new global::LiveKit.Proto.TextStreamReaderReadAllRequest(); + } + TextReadAll.MergeFrom(other.TextReadAll); + break; + case MessageOneofCase.SendFile: + if (SendFile == null) { + SendFile = new global::LiveKit.Proto.StreamSendFileRequest(); + } + SendFile.MergeFrom(other.SendFile); + break; + case MessageOneofCase.SendText: + if (SendText == null) { + SendText = new global::LiveKit.Proto.StreamSendTextRequest(); + } + SendText.MergeFrom(other.SendText); + break; + case MessageOneofCase.ByteStreamOpen: + if (ByteStreamOpen == null) { + ByteStreamOpen = new global::LiveKit.Proto.ByteStreamOpenRequest(); + } + ByteStreamOpen.MergeFrom(other.ByteStreamOpen); + break; + case MessageOneofCase.ByteStreamWrite: + if (ByteStreamWrite == null) { + ByteStreamWrite = new global::LiveKit.Proto.ByteStreamWriterWriteRequest(); + } + ByteStreamWrite.MergeFrom(other.ByteStreamWrite); + break; + case MessageOneofCase.ByteStreamClose: + if (ByteStreamClose == null) { + ByteStreamClose = new global::LiveKit.Proto.ByteStreamWriterCloseRequest(); + } + ByteStreamClose.MergeFrom(other.ByteStreamClose); + break; + case MessageOneofCase.TextStreamOpen: + if (TextStreamOpen == null) { + TextStreamOpen = new global::LiveKit.Proto.TextStreamOpenRequest(); + } + TextStreamOpen.MergeFrom(other.TextStreamOpen); + break; + case MessageOneofCase.TextStreamWrite: + if (TextStreamWrite == null) { + TextStreamWrite = new global::LiveKit.Proto.TextStreamWriterWriteRequest(); + } + TextStreamWrite.MergeFrom(other.TextStreamWrite); + break; + case MessageOneofCase.TextStreamClose: + if (TextStreamClose == null) { + TextStreamClose = new global::LiveKit.Proto.TextStreamWriterCloseRequest(); + } + TextStreamClose.MergeFrom(other.TextStreamClose); + break; } _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); @@ -2159,6 +3164,231 @@ public void MergeFrom(pb::CodedInputStream input) { RpcMethodInvocationResponse = subBuilder; break; } + case 338: { + global::LiveKit.Proto.EnableRemoteTrackPublicationRequest subBuilder = new global::LiveKit.Proto.EnableRemoteTrackPublicationRequest(); + if (messageCase_ == MessageOneofCase.EnableRemoteTrackPublication) { + subBuilder.MergeFrom(EnableRemoteTrackPublication); + } + input.ReadMessage(subBuilder); + EnableRemoteTrackPublication = subBuilder; + break; + } + case 346: { + global::LiveKit.Proto.UpdateRemoteTrackPublicationDimensionRequest subBuilder = new global::LiveKit.Proto.UpdateRemoteTrackPublicationDimensionRequest(); + if (messageCase_ == MessageOneofCase.UpdateRemoteTrackPublicationDimension) { + subBuilder.MergeFrom(UpdateRemoteTrackPublicationDimension); + } + input.ReadMessage(subBuilder); + UpdateRemoteTrackPublicationDimension = subBuilder; + break; + } + case 354: { + global::LiveKit.Proto.SendStreamHeaderRequest subBuilder = new global::LiveKit.Proto.SendStreamHeaderRequest(); + if (messageCase_ == MessageOneofCase.SendStreamHeader) { + subBuilder.MergeFrom(SendStreamHeader); + } + input.ReadMessage(subBuilder); + SendStreamHeader = subBuilder; + break; + } + case 362: { + global::LiveKit.Proto.SendStreamChunkRequest subBuilder = new global::LiveKit.Proto.SendStreamChunkRequest(); + if (messageCase_ == MessageOneofCase.SendStreamChunk) { + subBuilder.MergeFrom(SendStreamChunk); + } + input.ReadMessage(subBuilder); + SendStreamChunk = subBuilder; + break; + } + case 370: { + global::LiveKit.Proto.SendStreamTrailerRequest subBuilder = new global::LiveKit.Proto.SendStreamTrailerRequest(); + if (messageCase_ == MessageOneofCase.SendStreamTrailer) { + subBuilder.MergeFrom(SendStreamTrailer); + } + input.ReadMessage(subBuilder); + SendStreamTrailer = subBuilder; + break; + } + case 378: { + global::LiveKit.Proto.SetDataChannelBufferedAmountLowThresholdRequest subBuilder = new global::LiveKit.Proto.SetDataChannelBufferedAmountLowThresholdRequest(); + if (messageCase_ == MessageOneofCase.SetDataChannelBufferedAmountLowThreshold) { + subBuilder.MergeFrom(SetDataChannelBufferedAmountLowThreshold); + } + input.ReadMessage(subBuilder); + SetDataChannelBufferedAmountLowThreshold = subBuilder; + break; + } + case 386: { + global::LiveKit.Proto.SetTrackSubscriptionPermissionsRequest subBuilder = new global::LiveKit.Proto.SetTrackSubscriptionPermissionsRequest(); + if (messageCase_ == MessageOneofCase.SetTrackSubscriptionPermissions) { + subBuilder.MergeFrom(SetTrackSubscriptionPermissions); + } + input.ReadMessage(subBuilder); + SetTrackSubscriptionPermissions = subBuilder; + break; + } + case 394: { + global::LiveKit.Proto.LoadAudioFilterPluginRequest subBuilder = new global::LiveKit.Proto.LoadAudioFilterPluginRequest(); + if (messageCase_ == MessageOneofCase.LoadAudioFilterPlugin) { + subBuilder.MergeFrom(LoadAudioFilterPlugin); + } + input.ReadMessage(subBuilder); + LoadAudioFilterPlugin = subBuilder; + break; + } + case 402: { + global::LiveKit.Proto.NewApmRequest subBuilder = new global::LiveKit.Proto.NewApmRequest(); + if (messageCase_ == MessageOneofCase.NewApm) { + subBuilder.MergeFrom(NewApm); + } + input.ReadMessage(subBuilder); + NewApm = subBuilder; + break; + } + case 410: { + global::LiveKit.Proto.ApmProcessStreamRequest subBuilder = new global::LiveKit.Proto.ApmProcessStreamRequest(); + if (messageCase_ == MessageOneofCase.ApmProcessStream) { + subBuilder.MergeFrom(ApmProcessStream); + } + input.ReadMessage(subBuilder); + ApmProcessStream = subBuilder; + break; + } + case 418: { + global::LiveKit.Proto.ApmProcessReverseStreamRequest subBuilder = new global::LiveKit.Proto.ApmProcessReverseStreamRequest(); + if (messageCase_ == MessageOneofCase.ApmProcessReverseStream) { + subBuilder.MergeFrom(ApmProcessReverseStream); + } + input.ReadMessage(subBuilder); + ApmProcessReverseStream = subBuilder; + break; + } + case 426: { + global::LiveKit.Proto.ApmSetStreamDelayRequest subBuilder = new global::LiveKit.Proto.ApmSetStreamDelayRequest(); + if (messageCase_ == MessageOneofCase.ApmSetStreamDelay) { + subBuilder.MergeFrom(ApmSetStreamDelay); + } + input.ReadMessage(subBuilder); + ApmSetStreamDelay = subBuilder; + break; + } + case 434: { + global::LiveKit.Proto.ByteStreamReaderReadIncrementalRequest subBuilder = new global::LiveKit.Proto.ByteStreamReaderReadIncrementalRequest(); + if (messageCase_ == MessageOneofCase.ByteReadIncremental) { + subBuilder.MergeFrom(ByteReadIncremental); + } + input.ReadMessage(subBuilder); + ByteReadIncremental = subBuilder; + break; + } + case 442: { + global::LiveKit.Proto.ByteStreamReaderReadAllRequest subBuilder = new global::LiveKit.Proto.ByteStreamReaderReadAllRequest(); + if (messageCase_ == MessageOneofCase.ByteReadAll) { + subBuilder.MergeFrom(ByteReadAll); + } + input.ReadMessage(subBuilder); + ByteReadAll = subBuilder; + break; + } + case 450: { + global::LiveKit.Proto.ByteStreamReaderWriteToFileRequest subBuilder = new global::LiveKit.Proto.ByteStreamReaderWriteToFileRequest(); + if (messageCase_ == MessageOneofCase.ByteWriteToFile) { + subBuilder.MergeFrom(ByteWriteToFile); + } + input.ReadMessage(subBuilder); + ByteWriteToFile = subBuilder; + break; + } + case 458: { + global::LiveKit.Proto.TextStreamReaderReadIncrementalRequest subBuilder = new global::LiveKit.Proto.TextStreamReaderReadIncrementalRequest(); + if (messageCase_ == MessageOneofCase.TextReadIncremental) { + subBuilder.MergeFrom(TextReadIncremental); + } + input.ReadMessage(subBuilder); + TextReadIncremental = subBuilder; + break; + } + case 466: { + global::LiveKit.Proto.TextStreamReaderReadAllRequest subBuilder = new global::LiveKit.Proto.TextStreamReaderReadAllRequest(); + if (messageCase_ == MessageOneofCase.TextReadAll) { + subBuilder.MergeFrom(TextReadAll); + } + input.ReadMessage(subBuilder); + TextReadAll = subBuilder; + break; + } + case 474: { + global::LiveKit.Proto.StreamSendFileRequest subBuilder = new global::LiveKit.Proto.StreamSendFileRequest(); + if (messageCase_ == MessageOneofCase.SendFile) { + subBuilder.MergeFrom(SendFile); + } + input.ReadMessage(subBuilder); + SendFile = subBuilder; + break; + } + case 482: { + global::LiveKit.Proto.StreamSendTextRequest subBuilder = new global::LiveKit.Proto.StreamSendTextRequest(); + if (messageCase_ == MessageOneofCase.SendText) { + subBuilder.MergeFrom(SendText); + } + input.ReadMessage(subBuilder); + SendText = subBuilder; + break; + } + case 490: { + global::LiveKit.Proto.ByteStreamOpenRequest subBuilder = new global::LiveKit.Proto.ByteStreamOpenRequest(); + if (messageCase_ == MessageOneofCase.ByteStreamOpen) { + subBuilder.MergeFrom(ByteStreamOpen); + } + input.ReadMessage(subBuilder); + ByteStreamOpen = subBuilder; + break; + } + case 498: { + global::LiveKit.Proto.ByteStreamWriterWriteRequest subBuilder = new global::LiveKit.Proto.ByteStreamWriterWriteRequest(); + if (messageCase_ == MessageOneofCase.ByteStreamWrite) { + subBuilder.MergeFrom(ByteStreamWrite); + } + input.ReadMessage(subBuilder); + ByteStreamWrite = subBuilder; + break; + } + case 506: { + global::LiveKit.Proto.ByteStreamWriterCloseRequest subBuilder = new global::LiveKit.Proto.ByteStreamWriterCloseRequest(); + if (messageCase_ == MessageOneofCase.ByteStreamClose) { + subBuilder.MergeFrom(ByteStreamClose); + } + input.ReadMessage(subBuilder); + ByteStreamClose = subBuilder; + break; + } + case 514: { + global::LiveKit.Proto.TextStreamOpenRequest subBuilder = new global::LiveKit.Proto.TextStreamOpenRequest(); + if (messageCase_ == MessageOneofCase.TextStreamOpen) { + subBuilder.MergeFrom(TextStreamOpen); + } + input.ReadMessage(subBuilder); + TextStreamOpen = subBuilder; + break; + } + case 522: { + global::LiveKit.Proto.TextStreamWriterWriteRequest subBuilder = new global::LiveKit.Proto.TextStreamWriterWriteRequest(); + if (messageCase_ == MessageOneofCase.TextStreamWrite) { + subBuilder.MergeFrom(TextStreamWrite); + } + input.ReadMessage(subBuilder); + TextStreamWrite = subBuilder; + break; + } + case 530: { + global::LiveKit.Proto.TextStreamWriterCloseRequest subBuilder = new global::LiveKit.Proto.TextStreamWriterCloseRequest(); + if (messageCase_ == MessageOneofCase.TextStreamClose) { + subBuilder.MergeFrom(TextStreamClose); + } + input.ReadMessage(subBuilder); + TextStreamClose = subBuilder; + break; + } } } #endif @@ -2538,41 +3768,266 @@ public void MergeFrom(pb::CodedInputStream input) { RpcMethodInvocationResponse = subBuilder; break; } - } - } - } - #endif - - } - - /// - /// This is the output of livekit_ffi_request function. - /// - [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] - public sealed partial class FfiResponse : pb::IMessage - #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE - , pb::IBufferMessage - #endif - { - private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new FfiResponse()); - private pb::UnknownFieldSet _unknownFields; - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public static pb::MessageParser Parser { get { return _parser; } } - - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public static pbr::MessageDescriptor Descriptor { - get { return global::LiveKit.Proto.FfiReflection.Descriptor.MessageTypes[1]; } - } - - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - pbr::MessageDescriptor pb::IMessage.Descriptor { - get { return Descriptor; } - } - - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + case 338: { + global::LiveKit.Proto.EnableRemoteTrackPublicationRequest subBuilder = new global::LiveKit.Proto.EnableRemoteTrackPublicationRequest(); + if (messageCase_ == MessageOneofCase.EnableRemoteTrackPublication) { + subBuilder.MergeFrom(EnableRemoteTrackPublication); + } + input.ReadMessage(subBuilder); + EnableRemoteTrackPublication = subBuilder; + break; + } + case 346: { + global::LiveKit.Proto.UpdateRemoteTrackPublicationDimensionRequest subBuilder = new global::LiveKit.Proto.UpdateRemoteTrackPublicationDimensionRequest(); + if (messageCase_ == MessageOneofCase.UpdateRemoteTrackPublicationDimension) { + subBuilder.MergeFrom(UpdateRemoteTrackPublicationDimension); + } + input.ReadMessage(subBuilder); + UpdateRemoteTrackPublicationDimension = subBuilder; + break; + } + case 354: { + global::LiveKit.Proto.SendStreamHeaderRequest subBuilder = new global::LiveKit.Proto.SendStreamHeaderRequest(); + if (messageCase_ == MessageOneofCase.SendStreamHeader) { + subBuilder.MergeFrom(SendStreamHeader); + } + input.ReadMessage(subBuilder); + SendStreamHeader = subBuilder; + break; + } + case 362: { + global::LiveKit.Proto.SendStreamChunkRequest subBuilder = new global::LiveKit.Proto.SendStreamChunkRequest(); + if (messageCase_ == MessageOneofCase.SendStreamChunk) { + subBuilder.MergeFrom(SendStreamChunk); + } + input.ReadMessage(subBuilder); + SendStreamChunk = subBuilder; + break; + } + case 370: { + global::LiveKit.Proto.SendStreamTrailerRequest subBuilder = new global::LiveKit.Proto.SendStreamTrailerRequest(); + if (messageCase_ == MessageOneofCase.SendStreamTrailer) { + subBuilder.MergeFrom(SendStreamTrailer); + } + input.ReadMessage(subBuilder); + SendStreamTrailer = subBuilder; + break; + } + case 378: { + global::LiveKit.Proto.SetDataChannelBufferedAmountLowThresholdRequest subBuilder = new global::LiveKit.Proto.SetDataChannelBufferedAmountLowThresholdRequest(); + if (messageCase_ == MessageOneofCase.SetDataChannelBufferedAmountLowThreshold) { + subBuilder.MergeFrom(SetDataChannelBufferedAmountLowThreshold); + } + input.ReadMessage(subBuilder); + SetDataChannelBufferedAmountLowThreshold = subBuilder; + break; + } + case 386: { + global::LiveKit.Proto.SetTrackSubscriptionPermissionsRequest subBuilder = new global::LiveKit.Proto.SetTrackSubscriptionPermissionsRequest(); + if (messageCase_ == MessageOneofCase.SetTrackSubscriptionPermissions) { + subBuilder.MergeFrom(SetTrackSubscriptionPermissions); + } + input.ReadMessage(subBuilder); + SetTrackSubscriptionPermissions = subBuilder; + break; + } + case 394: { + global::LiveKit.Proto.LoadAudioFilterPluginRequest subBuilder = new global::LiveKit.Proto.LoadAudioFilterPluginRequest(); + if (messageCase_ == MessageOneofCase.LoadAudioFilterPlugin) { + subBuilder.MergeFrom(LoadAudioFilterPlugin); + } + input.ReadMessage(subBuilder); + LoadAudioFilterPlugin = subBuilder; + break; + } + case 402: { + global::LiveKit.Proto.NewApmRequest subBuilder = new global::LiveKit.Proto.NewApmRequest(); + if (messageCase_ == MessageOneofCase.NewApm) { + subBuilder.MergeFrom(NewApm); + } + input.ReadMessage(subBuilder); + NewApm = subBuilder; + break; + } + case 410: { + global::LiveKit.Proto.ApmProcessStreamRequest subBuilder = new global::LiveKit.Proto.ApmProcessStreamRequest(); + if (messageCase_ == MessageOneofCase.ApmProcessStream) { + subBuilder.MergeFrom(ApmProcessStream); + } + input.ReadMessage(subBuilder); + ApmProcessStream = subBuilder; + break; + } + case 418: { + global::LiveKit.Proto.ApmProcessReverseStreamRequest subBuilder = new global::LiveKit.Proto.ApmProcessReverseStreamRequest(); + if (messageCase_ == MessageOneofCase.ApmProcessReverseStream) { + subBuilder.MergeFrom(ApmProcessReverseStream); + } + input.ReadMessage(subBuilder); + ApmProcessReverseStream = subBuilder; + break; + } + case 426: { + global::LiveKit.Proto.ApmSetStreamDelayRequest subBuilder = new global::LiveKit.Proto.ApmSetStreamDelayRequest(); + if (messageCase_ == MessageOneofCase.ApmSetStreamDelay) { + subBuilder.MergeFrom(ApmSetStreamDelay); + } + input.ReadMessage(subBuilder); + ApmSetStreamDelay = subBuilder; + break; + } + case 434: { + global::LiveKit.Proto.ByteStreamReaderReadIncrementalRequest subBuilder = new global::LiveKit.Proto.ByteStreamReaderReadIncrementalRequest(); + if (messageCase_ == MessageOneofCase.ByteReadIncremental) { + subBuilder.MergeFrom(ByteReadIncremental); + } + input.ReadMessage(subBuilder); + ByteReadIncremental = subBuilder; + break; + } + case 442: { + global::LiveKit.Proto.ByteStreamReaderReadAllRequest subBuilder = new global::LiveKit.Proto.ByteStreamReaderReadAllRequest(); + if (messageCase_ == MessageOneofCase.ByteReadAll) { + subBuilder.MergeFrom(ByteReadAll); + } + input.ReadMessage(subBuilder); + ByteReadAll = subBuilder; + break; + } + case 450: { + global::LiveKit.Proto.ByteStreamReaderWriteToFileRequest subBuilder = new global::LiveKit.Proto.ByteStreamReaderWriteToFileRequest(); + if (messageCase_ == MessageOneofCase.ByteWriteToFile) { + subBuilder.MergeFrom(ByteWriteToFile); + } + input.ReadMessage(subBuilder); + ByteWriteToFile = subBuilder; + break; + } + case 458: { + global::LiveKit.Proto.TextStreamReaderReadIncrementalRequest subBuilder = new global::LiveKit.Proto.TextStreamReaderReadIncrementalRequest(); + if (messageCase_ == MessageOneofCase.TextReadIncremental) { + subBuilder.MergeFrom(TextReadIncremental); + } + input.ReadMessage(subBuilder); + TextReadIncremental = subBuilder; + break; + } + case 466: { + global::LiveKit.Proto.TextStreamReaderReadAllRequest subBuilder = new global::LiveKit.Proto.TextStreamReaderReadAllRequest(); + if (messageCase_ == MessageOneofCase.TextReadAll) { + subBuilder.MergeFrom(TextReadAll); + } + input.ReadMessage(subBuilder); + TextReadAll = subBuilder; + break; + } + case 474: { + global::LiveKit.Proto.StreamSendFileRequest subBuilder = new global::LiveKit.Proto.StreamSendFileRequest(); + if (messageCase_ == MessageOneofCase.SendFile) { + subBuilder.MergeFrom(SendFile); + } + input.ReadMessage(subBuilder); + SendFile = subBuilder; + break; + } + case 482: { + global::LiveKit.Proto.StreamSendTextRequest subBuilder = new global::LiveKit.Proto.StreamSendTextRequest(); + if (messageCase_ == MessageOneofCase.SendText) { + subBuilder.MergeFrom(SendText); + } + input.ReadMessage(subBuilder); + SendText = subBuilder; + break; + } + case 490: { + global::LiveKit.Proto.ByteStreamOpenRequest subBuilder = new global::LiveKit.Proto.ByteStreamOpenRequest(); + if (messageCase_ == MessageOneofCase.ByteStreamOpen) { + subBuilder.MergeFrom(ByteStreamOpen); + } + input.ReadMessage(subBuilder); + ByteStreamOpen = subBuilder; + break; + } + case 498: { + global::LiveKit.Proto.ByteStreamWriterWriteRequest subBuilder = new global::LiveKit.Proto.ByteStreamWriterWriteRequest(); + if (messageCase_ == MessageOneofCase.ByteStreamWrite) { + subBuilder.MergeFrom(ByteStreamWrite); + } + input.ReadMessage(subBuilder); + ByteStreamWrite = subBuilder; + break; + } + case 506: { + global::LiveKit.Proto.ByteStreamWriterCloseRequest subBuilder = new global::LiveKit.Proto.ByteStreamWriterCloseRequest(); + if (messageCase_ == MessageOneofCase.ByteStreamClose) { + subBuilder.MergeFrom(ByteStreamClose); + } + input.ReadMessage(subBuilder); + ByteStreamClose = subBuilder; + break; + } + case 514: { + global::LiveKit.Proto.TextStreamOpenRequest subBuilder = new global::LiveKit.Proto.TextStreamOpenRequest(); + if (messageCase_ == MessageOneofCase.TextStreamOpen) { + subBuilder.MergeFrom(TextStreamOpen); + } + input.ReadMessage(subBuilder); + TextStreamOpen = subBuilder; + break; + } + case 522: { + global::LiveKit.Proto.TextStreamWriterWriteRequest subBuilder = new global::LiveKit.Proto.TextStreamWriterWriteRequest(); + if (messageCase_ == MessageOneofCase.TextStreamWrite) { + subBuilder.MergeFrom(TextStreamWrite); + } + input.ReadMessage(subBuilder); + TextStreamWrite = subBuilder; + break; + } + case 530: { + global::LiveKit.Proto.TextStreamWriterCloseRequest subBuilder = new global::LiveKit.Proto.TextStreamWriterCloseRequest(); + if (messageCase_ == MessageOneofCase.TextStreamClose) { + subBuilder.MergeFrom(TextStreamClose); + } + input.ReadMessage(subBuilder); + TextStreamClose = subBuilder; + break; + } + } + } + } + #endif + + } + + /// + /// This is the output of livekit_ffi_request function. + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class FfiResponse : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new FfiResponse()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.FfiReflection.Descriptor.MessageTypes[1]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public FfiResponse() { OnConstruction(); @@ -2638,6 +4093,9 @@ public FfiResponse(FfiResponse other) : this() { case MessageOneofCase.GetStats: GetStats = other.GetStats.Clone(); break; + case MessageOneofCase.SetTrackSubscriptionPermissions: + SetTrackSubscriptionPermissions = other.SetTrackSubscriptionPermissions.Clone(); + break; case MessageOneofCase.NewVideoStream: NewVideoStream = other.NewVideoStream.Clone(); break; @@ -2701,6 +4159,78 @@ public FfiResponse(FfiResponse other) : this() { case MessageOneofCase.RpcMethodInvocationResponse: RpcMethodInvocationResponse = other.RpcMethodInvocationResponse.Clone(); break; + case MessageOneofCase.EnableRemoteTrackPublication: + EnableRemoteTrackPublication = other.EnableRemoteTrackPublication.Clone(); + break; + case MessageOneofCase.UpdateRemoteTrackPublicationDimension: + UpdateRemoteTrackPublicationDimension = other.UpdateRemoteTrackPublicationDimension.Clone(); + break; + case MessageOneofCase.SendStreamHeader: + SendStreamHeader = other.SendStreamHeader.Clone(); + break; + case MessageOneofCase.SendStreamChunk: + SendStreamChunk = other.SendStreamChunk.Clone(); + break; + case MessageOneofCase.SendStreamTrailer: + SendStreamTrailer = other.SendStreamTrailer.Clone(); + break; + case MessageOneofCase.SetDataChannelBufferedAmountLowThreshold: + SetDataChannelBufferedAmountLowThreshold = other.SetDataChannelBufferedAmountLowThreshold.Clone(); + break; + case MessageOneofCase.LoadAudioFilterPlugin: + LoadAudioFilterPlugin = other.LoadAudioFilterPlugin.Clone(); + break; + case MessageOneofCase.NewApm: + NewApm = other.NewApm.Clone(); + break; + case MessageOneofCase.ApmProcessStream: + ApmProcessStream = other.ApmProcessStream.Clone(); + break; + case MessageOneofCase.ApmProcessReverseStream: + ApmProcessReverseStream = other.ApmProcessReverseStream.Clone(); + break; + case MessageOneofCase.ApmSetStreamDelay: + ApmSetStreamDelay = other.ApmSetStreamDelay.Clone(); + break; + case MessageOneofCase.ByteReadIncremental: + ByteReadIncremental = other.ByteReadIncremental.Clone(); + break; + case MessageOneofCase.ByteReadAll: + ByteReadAll = other.ByteReadAll.Clone(); + break; + case MessageOneofCase.ByteWriteToFile: + ByteWriteToFile = other.ByteWriteToFile.Clone(); + break; + case MessageOneofCase.TextReadIncremental: + TextReadIncremental = other.TextReadIncremental.Clone(); + break; + case MessageOneofCase.TextReadAll: + TextReadAll = other.TextReadAll.Clone(); + break; + case MessageOneofCase.SendFile: + SendFile = other.SendFile.Clone(); + break; + case MessageOneofCase.SendText: + SendText = other.SendText.Clone(); + break; + case MessageOneofCase.ByteStreamOpen: + ByteStreamOpen = other.ByteStreamOpen.Clone(); + break; + case MessageOneofCase.ByteStreamWrite: + ByteStreamWrite = other.ByteStreamWrite.Clone(); + break; + case MessageOneofCase.ByteStreamClose: + ByteStreamClose = other.ByteStreamClose.Clone(); + break; + case MessageOneofCase.TextStreamOpen: + TextStreamOpen = other.TextStreamOpen.Clone(); + break; + case MessageOneofCase.TextStreamWrite: + TextStreamWrite = other.TextStreamWrite.Clone(); + break; + case MessageOneofCase.TextStreamClose: + TextStreamClose = other.TextStreamClose.Clone(); + break; } _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); @@ -2934,6 +4464,18 @@ public FfiResponse Clone() { } } + /// Field number for the "set_track_subscription_permissions" field. + public const int SetTrackSubscriptionPermissionsFieldNumber = 47; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.SetTrackSubscriptionPermissionsResponse SetTrackSubscriptionPermissions { + get { return messageCase_ == MessageOneofCase.SetTrackSubscriptionPermissions ? (global::LiveKit.Proto.SetTrackSubscriptionPermissionsResponse) message_ : null; } + set { + message_ = value; + messageCase_ = value == null ? MessageOneofCase.None : MessageOneofCase.SetTrackSubscriptionPermissions; + } + } + /// Field number for the "new_video_stream" field. public const int NewVideoStreamFieldNumber = 20; /// @@ -3195,83 +4737,411 @@ public FfiResponse Clone() { } } - private object message_; - /// Enum of possible cases for the "message" oneof. - public enum MessageOneofCase { - None = 0, - Dispose = 2, - Connect = 3, - Disconnect = 4, - PublishTrack = 5, - UnpublishTrack = 6, - PublishData = 7, - SetSubscribed = 8, - SetLocalMetadata = 9, - SetLocalName = 10, - SetLocalAttributes = 11, - GetSessionStats = 12, - PublishTranscription = 13, - PublishSipDtmf = 14, - CreateVideoTrack = 15, - CreateAudioTrack = 16, - LocalTrackMute = 17, - EnableRemoteTrack = 18, - GetStats = 19, - NewVideoStream = 20, - NewVideoSource = 21, - CaptureVideoFrame = 22, - VideoConvert = 23, - VideoStreamFromParticipant = 24, - NewAudioStream = 25, - NewAudioSource = 26, - CaptureAudioFrame = 27, - ClearAudioBuffer = 28, - NewAudioResampler = 29, - RemixAndResample = 30, - AudioStreamFromParticipant = 31, - E2Ee = 32, - NewSoxResampler = 33, - PushSoxResampler = 34, - FlushSoxResampler = 35, - SendChatMessage = 36, - PerformRpc = 37, - RegisterRpcMethod = 38, - UnregisterRpcMethod = 39, - RpcMethodInvocationResponse = 40, + /// Field number for the "enable_remote_track_publication" field. + public const int EnableRemoteTrackPublicationFieldNumber = 41; + /// + /// Track Publication + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.EnableRemoteTrackPublicationResponse EnableRemoteTrackPublication { + get { return messageCase_ == MessageOneofCase.EnableRemoteTrackPublication ? (global::LiveKit.Proto.EnableRemoteTrackPublicationResponse) message_ : null; } + set { + message_ = value; + messageCase_ = value == null ? MessageOneofCase.None : MessageOneofCase.EnableRemoteTrackPublication; + } } - private MessageOneofCase messageCase_ = MessageOneofCase.None; + + /// Field number for the "update_remote_track_publication_dimension" field. + public const int UpdateRemoteTrackPublicationDimensionFieldNumber = 42; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public MessageOneofCase MessageCase { - get { return messageCase_; } + public global::LiveKit.Proto.UpdateRemoteTrackPublicationDimensionResponse UpdateRemoteTrackPublicationDimension { + get { return messageCase_ == MessageOneofCase.UpdateRemoteTrackPublicationDimension ? (global::LiveKit.Proto.UpdateRemoteTrackPublicationDimensionResponse) message_ : null; } + set { + message_ = value; + messageCase_ = value == null ? MessageOneofCase.None : MessageOneofCase.UpdateRemoteTrackPublicationDimension; + } } + /// Field number for the "send_stream_header" field. + public const int SendStreamHeaderFieldNumber = 43; + /// + /// Data Streams + /// [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public void ClearMessage() { - messageCase_ = MessageOneofCase.None; - message_ = null; + public global::LiveKit.Proto.SendStreamHeaderResponse SendStreamHeader { + get { return messageCase_ == MessageOneofCase.SendStreamHeader ? (global::LiveKit.Proto.SendStreamHeaderResponse) message_ : null; } + set { + message_ = value; + messageCase_ = value == null ? MessageOneofCase.None : MessageOneofCase.SendStreamHeader; + } } + /// Field number for the "send_stream_chunk" field. + public const int SendStreamChunkFieldNumber = 44; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public override bool Equals(object other) { - return Equals(other as FfiResponse); + public global::LiveKit.Proto.SendStreamChunkResponse SendStreamChunk { + get { return messageCase_ == MessageOneofCase.SendStreamChunk ? (global::LiveKit.Proto.SendStreamChunkResponse) message_ : null; } + set { + message_ = value; + messageCase_ = value == null ? MessageOneofCase.None : MessageOneofCase.SendStreamChunk; + } } + /// Field number for the "send_stream_trailer" field. + public const int SendStreamTrailerFieldNumber = 45; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public bool Equals(FfiResponse other) { - if (ReferenceEquals(other, null)) { - return false; + public global::LiveKit.Proto.SendStreamTrailerResponse SendStreamTrailer { + get { return messageCase_ == MessageOneofCase.SendStreamTrailer ? (global::LiveKit.Proto.SendStreamTrailerResponse) message_ : null; } + set { + message_ = value; + messageCase_ = value == null ? MessageOneofCase.None : MessageOneofCase.SendStreamTrailer; } - if (ReferenceEquals(other, this)) { - return true; + } + + /// Field number for the "set_data_channel_buffered_amount_low_threshold" field. + public const int SetDataChannelBufferedAmountLowThresholdFieldNumber = 46; + /// + /// Data Channel + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.SetDataChannelBufferedAmountLowThresholdResponse SetDataChannelBufferedAmountLowThreshold { + get { return messageCase_ == MessageOneofCase.SetDataChannelBufferedAmountLowThreshold ? (global::LiveKit.Proto.SetDataChannelBufferedAmountLowThresholdResponse) message_ : null; } + set { + message_ = value; + messageCase_ = value == null ? MessageOneofCase.None : MessageOneofCase.SetDataChannelBufferedAmountLowThreshold; } - if (!object.Equals(Dispose, other.Dispose)) return false; - if (!object.Equals(Connect, other.Connect)) return false; - if (!object.Equals(Disconnect, other.Disconnect)) return false; - if (!object.Equals(PublishTrack, other.PublishTrack)) return false; + } + + /// Field number for the "load_audio_filter_plugin" field. + public const int LoadAudioFilterPluginFieldNumber = 48; + /// + /// Audio Filter Plugin + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.LoadAudioFilterPluginResponse LoadAudioFilterPlugin { + get { return messageCase_ == MessageOneofCase.LoadAudioFilterPlugin ? (global::LiveKit.Proto.LoadAudioFilterPluginResponse) message_ : null; } + set { + message_ = value; + messageCase_ = value == null ? MessageOneofCase.None : MessageOneofCase.LoadAudioFilterPlugin; + } + } + + /// Field number for the "new_apm" field. + public const int NewApmFieldNumber = 49; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.NewApmResponse NewApm { + get { return messageCase_ == MessageOneofCase.NewApm ? (global::LiveKit.Proto.NewApmResponse) message_ : null; } + set { + message_ = value; + messageCase_ = value == null ? MessageOneofCase.None : MessageOneofCase.NewApm; + } + } + + /// Field number for the "apm_process_stream" field. + public const int ApmProcessStreamFieldNumber = 50; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.ApmProcessStreamResponse ApmProcessStream { + get { return messageCase_ == MessageOneofCase.ApmProcessStream ? (global::LiveKit.Proto.ApmProcessStreamResponse) message_ : null; } + set { + message_ = value; + messageCase_ = value == null ? MessageOneofCase.None : MessageOneofCase.ApmProcessStream; + } + } + + /// Field number for the "apm_process_reverse_stream" field. + public const int ApmProcessReverseStreamFieldNumber = 51; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.ApmProcessReverseStreamResponse ApmProcessReverseStream { + get { return messageCase_ == MessageOneofCase.ApmProcessReverseStream ? (global::LiveKit.Proto.ApmProcessReverseStreamResponse) message_ : null; } + set { + message_ = value; + messageCase_ = value == null ? MessageOneofCase.None : MessageOneofCase.ApmProcessReverseStream; + } + } + + /// Field number for the "apm_set_stream_delay" field. + public const int ApmSetStreamDelayFieldNumber = 52; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.ApmSetStreamDelayResponse ApmSetStreamDelay { + get { return messageCase_ == MessageOneofCase.ApmSetStreamDelay ? (global::LiveKit.Proto.ApmSetStreamDelayResponse) message_ : null; } + set { + message_ = value; + messageCase_ = value == null ? MessageOneofCase.None : MessageOneofCase.ApmSetStreamDelay; + } + } + + /// Field number for the "byte_read_incremental" field. + public const int ByteReadIncrementalFieldNumber = 53; + /// + /// Data Streams (high level) + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.ByteStreamReaderReadIncrementalResponse ByteReadIncremental { + get { return messageCase_ == MessageOneofCase.ByteReadIncremental ? (global::LiveKit.Proto.ByteStreamReaderReadIncrementalResponse) message_ : null; } + set { + message_ = value; + messageCase_ = value == null ? MessageOneofCase.None : MessageOneofCase.ByteReadIncremental; + } + } + + /// Field number for the "byte_read_all" field. + public const int ByteReadAllFieldNumber = 54; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.ByteStreamReaderReadAllResponse ByteReadAll { + get { return messageCase_ == MessageOneofCase.ByteReadAll ? (global::LiveKit.Proto.ByteStreamReaderReadAllResponse) message_ : null; } + set { + message_ = value; + messageCase_ = value == null ? MessageOneofCase.None : MessageOneofCase.ByteReadAll; + } + } + + /// Field number for the "byte_write_to_file" field. + public const int ByteWriteToFileFieldNumber = 55; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.ByteStreamReaderWriteToFileResponse ByteWriteToFile { + get { return messageCase_ == MessageOneofCase.ByteWriteToFile ? (global::LiveKit.Proto.ByteStreamReaderWriteToFileResponse) message_ : null; } + set { + message_ = value; + messageCase_ = value == null ? MessageOneofCase.None : MessageOneofCase.ByteWriteToFile; + } + } + + /// Field number for the "text_read_incremental" field. + public const int TextReadIncrementalFieldNumber = 56; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.TextStreamReaderReadIncrementalResponse TextReadIncremental { + get { return messageCase_ == MessageOneofCase.TextReadIncremental ? (global::LiveKit.Proto.TextStreamReaderReadIncrementalResponse) message_ : null; } + set { + message_ = value; + messageCase_ = value == null ? MessageOneofCase.None : MessageOneofCase.TextReadIncremental; + } + } + + /// Field number for the "text_read_all" field. + public const int TextReadAllFieldNumber = 57; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.TextStreamReaderReadAllResponse TextReadAll { + get { return messageCase_ == MessageOneofCase.TextReadAll ? (global::LiveKit.Proto.TextStreamReaderReadAllResponse) message_ : null; } + set { + message_ = value; + messageCase_ = value == null ? MessageOneofCase.None : MessageOneofCase.TextReadAll; + } + } + + /// Field number for the "send_file" field. + public const int SendFileFieldNumber = 58; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.StreamSendFileResponse SendFile { + get { return messageCase_ == MessageOneofCase.SendFile ? (global::LiveKit.Proto.StreamSendFileResponse) message_ : null; } + set { + message_ = value; + messageCase_ = value == null ? MessageOneofCase.None : MessageOneofCase.SendFile; + } + } + + /// Field number for the "send_text" field. + public const int SendTextFieldNumber = 59; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.StreamSendTextResponse SendText { + get { return messageCase_ == MessageOneofCase.SendText ? (global::LiveKit.Proto.StreamSendTextResponse) message_ : null; } + set { + message_ = value; + messageCase_ = value == null ? MessageOneofCase.None : MessageOneofCase.SendText; + } + } + + /// Field number for the "byte_stream_open" field. + public const int ByteStreamOpenFieldNumber = 60; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.ByteStreamOpenResponse ByteStreamOpen { + get { return messageCase_ == MessageOneofCase.ByteStreamOpen ? (global::LiveKit.Proto.ByteStreamOpenResponse) message_ : null; } + set { + message_ = value; + messageCase_ = value == null ? MessageOneofCase.None : MessageOneofCase.ByteStreamOpen; + } + } + + /// Field number for the "byte_stream_write" field. + public const int ByteStreamWriteFieldNumber = 61; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.ByteStreamWriterWriteResponse ByteStreamWrite { + get { return messageCase_ == MessageOneofCase.ByteStreamWrite ? (global::LiveKit.Proto.ByteStreamWriterWriteResponse) message_ : null; } + set { + message_ = value; + messageCase_ = value == null ? MessageOneofCase.None : MessageOneofCase.ByteStreamWrite; + } + } + + /// Field number for the "byte_stream_close" field. + public const int ByteStreamCloseFieldNumber = 62; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.ByteStreamWriterCloseResponse ByteStreamClose { + get { return messageCase_ == MessageOneofCase.ByteStreamClose ? (global::LiveKit.Proto.ByteStreamWriterCloseResponse) message_ : null; } + set { + message_ = value; + messageCase_ = value == null ? MessageOneofCase.None : MessageOneofCase.ByteStreamClose; + } + } + + /// Field number for the "text_stream_open" field. + public const int TextStreamOpenFieldNumber = 63; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.TextStreamOpenResponse TextStreamOpen { + get { return messageCase_ == MessageOneofCase.TextStreamOpen ? (global::LiveKit.Proto.TextStreamOpenResponse) message_ : null; } + set { + message_ = value; + messageCase_ = value == null ? MessageOneofCase.None : MessageOneofCase.TextStreamOpen; + } + } + + /// Field number for the "text_stream_write" field. + public const int TextStreamWriteFieldNumber = 64; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.TextStreamWriterWriteResponse TextStreamWrite { + get { return messageCase_ == MessageOneofCase.TextStreamWrite ? (global::LiveKit.Proto.TextStreamWriterWriteResponse) message_ : null; } + set { + message_ = value; + messageCase_ = value == null ? MessageOneofCase.None : MessageOneofCase.TextStreamWrite; + } + } + + /// Field number for the "text_stream_close" field. + public const int TextStreamCloseFieldNumber = 65; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.TextStreamWriterCloseResponse TextStreamClose { + get { return messageCase_ == MessageOneofCase.TextStreamClose ? (global::LiveKit.Proto.TextStreamWriterCloseResponse) message_ : null; } + set { + message_ = value; + messageCase_ = value == null ? MessageOneofCase.None : MessageOneofCase.TextStreamClose; + } + } + + private object message_; + /// Enum of possible cases for the "message" oneof. + public enum MessageOneofCase { + None = 0, + Dispose = 2, + Connect = 3, + Disconnect = 4, + PublishTrack = 5, + UnpublishTrack = 6, + PublishData = 7, + SetSubscribed = 8, + SetLocalMetadata = 9, + SetLocalName = 10, + SetLocalAttributes = 11, + GetSessionStats = 12, + PublishTranscription = 13, + PublishSipDtmf = 14, + CreateVideoTrack = 15, + CreateAudioTrack = 16, + LocalTrackMute = 17, + EnableRemoteTrack = 18, + GetStats = 19, + SetTrackSubscriptionPermissions = 47, + NewVideoStream = 20, + NewVideoSource = 21, + CaptureVideoFrame = 22, + VideoConvert = 23, + VideoStreamFromParticipant = 24, + NewAudioStream = 25, + NewAudioSource = 26, + CaptureAudioFrame = 27, + ClearAudioBuffer = 28, + NewAudioResampler = 29, + RemixAndResample = 30, + AudioStreamFromParticipant = 31, + E2Ee = 32, + NewSoxResampler = 33, + PushSoxResampler = 34, + FlushSoxResampler = 35, + SendChatMessage = 36, + PerformRpc = 37, + RegisterRpcMethod = 38, + UnregisterRpcMethod = 39, + RpcMethodInvocationResponse = 40, + EnableRemoteTrackPublication = 41, + UpdateRemoteTrackPublicationDimension = 42, + SendStreamHeader = 43, + SendStreamChunk = 44, + SendStreamTrailer = 45, + SetDataChannelBufferedAmountLowThreshold = 46, + LoadAudioFilterPlugin = 48, + NewApm = 49, + ApmProcessStream = 50, + ApmProcessReverseStream = 51, + ApmSetStreamDelay = 52, + ByteReadIncremental = 53, + ByteReadAll = 54, + ByteWriteToFile = 55, + TextReadIncremental = 56, + TextReadAll = 57, + SendFile = 58, + SendText = 59, + ByteStreamOpen = 60, + ByteStreamWrite = 61, + ByteStreamClose = 62, + TextStreamOpen = 63, + TextStreamWrite = 64, + TextStreamClose = 65, + } + private MessageOneofCase messageCase_ = MessageOneofCase.None; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public MessageOneofCase MessageCase { + get { return messageCase_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearMessage() { + messageCase_ = MessageOneofCase.None; + message_ = null; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as FfiResponse); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(FfiResponse other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (!object.Equals(Dispose, other.Dispose)) return false; + if (!object.Equals(Connect, other.Connect)) return false; + if (!object.Equals(Disconnect, other.Disconnect)) return false; + if (!object.Equals(PublishTrack, other.PublishTrack)) return false; if (!object.Equals(UnpublishTrack, other.UnpublishTrack)) return false; if (!object.Equals(PublishData, other.PublishData)) return false; if (!object.Equals(SetSubscribed, other.SetSubscribed)) return false; @@ -3286,6 +5156,7 @@ public bool Equals(FfiResponse other) { if (!object.Equals(LocalTrackMute, other.LocalTrackMute)) return false; if (!object.Equals(EnableRemoteTrack, other.EnableRemoteTrack)) return false; if (!object.Equals(GetStats, other.GetStats)) return false; + if (!object.Equals(SetTrackSubscriptionPermissions, other.SetTrackSubscriptionPermissions)) return false; if (!object.Equals(NewVideoStream, other.NewVideoStream)) return false; if (!object.Equals(NewVideoSource, other.NewVideoSource)) return false; if (!object.Equals(CaptureVideoFrame, other.CaptureVideoFrame)) return false; @@ -3307,6 +5178,30 @@ public bool Equals(FfiResponse other) { if (!object.Equals(RegisterRpcMethod, other.RegisterRpcMethod)) return false; if (!object.Equals(UnregisterRpcMethod, other.UnregisterRpcMethod)) return false; if (!object.Equals(RpcMethodInvocationResponse, other.RpcMethodInvocationResponse)) return false; + if (!object.Equals(EnableRemoteTrackPublication, other.EnableRemoteTrackPublication)) return false; + if (!object.Equals(UpdateRemoteTrackPublicationDimension, other.UpdateRemoteTrackPublicationDimension)) return false; + if (!object.Equals(SendStreamHeader, other.SendStreamHeader)) return false; + if (!object.Equals(SendStreamChunk, other.SendStreamChunk)) return false; + if (!object.Equals(SendStreamTrailer, other.SendStreamTrailer)) return false; + if (!object.Equals(SetDataChannelBufferedAmountLowThreshold, other.SetDataChannelBufferedAmountLowThreshold)) return false; + if (!object.Equals(LoadAudioFilterPlugin, other.LoadAudioFilterPlugin)) return false; + if (!object.Equals(NewApm, other.NewApm)) return false; + if (!object.Equals(ApmProcessStream, other.ApmProcessStream)) return false; + if (!object.Equals(ApmProcessReverseStream, other.ApmProcessReverseStream)) return false; + if (!object.Equals(ApmSetStreamDelay, other.ApmSetStreamDelay)) return false; + if (!object.Equals(ByteReadIncremental, other.ByteReadIncremental)) return false; + if (!object.Equals(ByteReadAll, other.ByteReadAll)) return false; + if (!object.Equals(ByteWriteToFile, other.ByteWriteToFile)) return false; + if (!object.Equals(TextReadIncremental, other.TextReadIncremental)) return false; + if (!object.Equals(TextReadAll, other.TextReadAll)) return false; + if (!object.Equals(SendFile, other.SendFile)) return false; + if (!object.Equals(SendText, other.SendText)) return false; + if (!object.Equals(ByteStreamOpen, other.ByteStreamOpen)) return false; + if (!object.Equals(ByteStreamWrite, other.ByteStreamWrite)) return false; + if (!object.Equals(ByteStreamClose, other.ByteStreamClose)) return false; + if (!object.Equals(TextStreamOpen, other.TextStreamOpen)) return false; + if (!object.Equals(TextStreamWrite, other.TextStreamWrite)) return false; + if (!object.Equals(TextStreamClose, other.TextStreamClose)) return false; if (MessageCase != other.MessageCase) return false; return Equals(_unknownFields, other._unknownFields); } @@ -3333,6 +5228,7 @@ public override int GetHashCode() { if (messageCase_ == MessageOneofCase.LocalTrackMute) hash ^= LocalTrackMute.GetHashCode(); if (messageCase_ == MessageOneofCase.EnableRemoteTrack) hash ^= EnableRemoteTrack.GetHashCode(); if (messageCase_ == MessageOneofCase.GetStats) hash ^= GetStats.GetHashCode(); + if (messageCase_ == MessageOneofCase.SetTrackSubscriptionPermissions) hash ^= SetTrackSubscriptionPermissions.GetHashCode(); if (messageCase_ == MessageOneofCase.NewVideoStream) hash ^= NewVideoStream.GetHashCode(); if (messageCase_ == MessageOneofCase.NewVideoSource) hash ^= NewVideoSource.GetHashCode(); if (messageCase_ == MessageOneofCase.CaptureVideoFrame) hash ^= CaptureVideoFrame.GetHashCode(); @@ -3354,6 +5250,30 @@ public override int GetHashCode() { if (messageCase_ == MessageOneofCase.RegisterRpcMethod) hash ^= RegisterRpcMethod.GetHashCode(); if (messageCase_ == MessageOneofCase.UnregisterRpcMethod) hash ^= UnregisterRpcMethod.GetHashCode(); if (messageCase_ == MessageOneofCase.RpcMethodInvocationResponse) hash ^= RpcMethodInvocationResponse.GetHashCode(); + if (messageCase_ == MessageOneofCase.EnableRemoteTrackPublication) hash ^= EnableRemoteTrackPublication.GetHashCode(); + if (messageCase_ == MessageOneofCase.UpdateRemoteTrackPublicationDimension) hash ^= UpdateRemoteTrackPublicationDimension.GetHashCode(); + if (messageCase_ == MessageOneofCase.SendStreamHeader) hash ^= SendStreamHeader.GetHashCode(); + if (messageCase_ == MessageOneofCase.SendStreamChunk) hash ^= SendStreamChunk.GetHashCode(); + if (messageCase_ == MessageOneofCase.SendStreamTrailer) hash ^= SendStreamTrailer.GetHashCode(); + if (messageCase_ == MessageOneofCase.SetDataChannelBufferedAmountLowThreshold) hash ^= SetDataChannelBufferedAmountLowThreshold.GetHashCode(); + if (messageCase_ == MessageOneofCase.LoadAudioFilterPlugin) hash ^= LoadAudioFilterPlugin.GetHashCode(); + if (messageCase_ == MessageOneofCase.NewApm) hash ^= NewApm.GetHashCode(); + if (messageCase_ == MessageOneofCase.ApmProcessStream) hash ^= ApmProcessStream.GetHashCode(); + if (messageCase_ == MessageOneofCase.ApmProcessReverseStream) hash ^= ApmProcessReverseStream.GetHashCode(); + if (messageCase_ == MessageOneofCase.ApmSetStreamDelay) hash ^= ApmSetStreamDelay.GetHashCode(); + if (messageCase_ == MessageOneofCase.ByteReadIncremental) hash ^= ByteReadIncremental.GetHashCode(); + if (messageCase_ == MessageOneofCase.ByteReadAll) hash ^= ByteReadAll.GetHashCode(); + if (messageCase_ == MessageOneofCase.ByteWriteToFile) hash ^= ByteWriteToFile.GetHashCode(); + if (messageCase_ == MessageOneofCase.TextReadIncremental) hash ^= TextReadIncremental.GetHashCode(); + if (messageCase_ == MessageOneofCase.TextReadAll) hash ^= TextReadAll.GetHashCode(); + if (messageCase_ == MessageOneofCase.SendFile) hash ^= SendFile.GetHashCode(); + if (messageCase_ == MessageOneofCase.SendText) hash ^= SendText.GetHashCode(); + if (messageCase_ == MessageOneofCase.ByteStreamOpen) hash ^= ByteStreamOpen.GetHashCode(); + if (messageCase_ == MessageOneofCase.ByteStreamWrite) hash ^= ByteStreamWrite.GetHashCode(); + if (messageCase_ == MessageOneofCase.ByteStreamClose) hash ^= ByteStreamClose.GetHashCode(); + if (messageCase_ == MessageOneofCase.TextStreamOpen) hash ^= TextStreamOpen.GetHashCode(); + if (messageCase_ == MessageOneofCase.TextStreamWrite) hash ^= TextStreamWrite.GetHashCode(); + if (messageCase_ == MessageOneofCase.TextStreamClose) hash ^= TextStreamClose.GetHashCode(); hash ^= (int) messageCase_; if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); @@ -3529,6 +5449,106 @@ public void WriteTo(pb::CodedOutputStream output) { output.WriteRawTag(194, 2); output.WriteMessage(RpcMethodInvocationResponse); } + if (messageCase_ == MessageOneofCase.EnableRemoteTrackPublication) { + output.WriteRawTag(202, 2); + output.WriteMessage(EnableRemoteTrackPublication); + } + if (messageCase_ == MessageOneofCase.UpdateRemoteTrackPublicationDimension) { + output.WriteRawTag(210, 2); + output.WriteMessage(UpdateRemoteTrackPublicationDimension); + } + if (messageCase_ == MessageOneofCase.SendStreamHeader) { + output.WriteRawTag(218, 2); + output.WriteMessage(SendStreamHeader); + } + if (messageCase_ == MessageOneofCase.SendStreamChunk) { + output.WriteRawTag(226, 2); + output.WriteMessage(SendStreamChunk); + } + if (messageCase_ == MessageOneofCase.SendStreamTrailer) { + output.WriteRawTag(234, 2); + output.WriteMessage(SendStreamTrailer); + } + if (messageCase_ == MessageOneofCase.SetDataChannelBufferedAmountLowThreshold) { + output.WriteRawTag(242, 2); + output.WriteMessage(SetDataChannelBufferedAmountLowThreshold); + } + if (messageCase_ == MessageOneofCase.SetTrackSubscriptionPermissions) { + output.WriteRawTag(250, 2); + output.WriteMessage(SetTrackSubscriptionPermissions); + } + if (messageCase_ == MessageOneofCase.LoadAudioFilterPlugin) { + output.WriteRawTag(130, 3); + output.WriteMessage(LoadAudioFilterPlugin); + } + if (messageCase_ == MessageOneofCase.NewApm) { + output.WriteRawTag(138, 3); + output.WriteMessage(NewApm); + } + if (messageCase_ == MessageOneofCase.ApmProcessStream) { + output.WriteRawTag(146, 3); + output.WriteMessage(ApmProcessStream); + } + if (messageCase_ == MessageOneofCase.ApmProcessReverseStream) { + output.WriteRawTag(154, 3); + output.WriteMessage(ApmProcessReverseStream); + } + if (messageCase_ == MessageOneofCase.ApmSetStreamDelay) { + output.WriteRawTag(162, 3); + output.WriteMessage(ApmSetStreamDelay); + } + if (messageCase_ == MessageOneofCase.ByteReadIncremental) { + output.WriteRawTag(170, 3); + output.WriteMessage(ByteReadIncremental); + } + if (messageCase_ == MessageOneofCase.ByteReadAll) { + output.WriteRawTag(178, 3); + output.WriteMessage(ByteReadAll); + } + if (messageCase_ == MessageOneofCase.ByteWriteToFile) { + output.WriteRawTag(186, 3); + output.WriteMessage(ByteWriteToFile); + } + if (messageCase_ == MessageOneofCase.TextReadIncremental) { + output.WriteRawTag(194, 3); + output.WriteMessage(TextReadIncremental); + } + if (messageCase_ == MessageOneofCase.TextReadAll) { + output.WriteRawTag(202, 3); + output.WriteMessage(TextReadAll); + } + if (messageCase_ == MessageOneofCase.SendFile) { + output.WriteRawTag(210, 3); + output.WriteMessage(SendFile); + } + if (messageCase_ == MessageOneofCase.SendText) { + output.WriteRawTag(218, 3); + output.WriteMessage(SendText); + } + if (messageCase_ == MessageOneofCase.ByteStreamOpen) { + output.WriteRawTag(226, 3); + output.WriteMessage(ByteStreamOpen); + } + if (messageCase_ == MessageOneofCase.ByteStreamWrite) { + output.WriteRawTag(234, 3); + output.WriteMessage(ByteStreamWrite); + } + if (messageCase_ == MessageOneofCase.ByteStreamClose) { + output.WriteRawTag(242, 3); + output.WriteMessage(ByteStreamClose); + } + if (messageCase_ == MessageOneofCase.TextStreamOpen) { + output.WriteRawTag(250, 3); + output.WriteMessage(TextStreamOpen); + } + if (messageCase_ == MessageOneofCase.TextStreamWrite) { + output.WriteRawTag(130, 4); + output.WriteMessage(TextStreamWrite); + } + if (messageCase_ == MessageOneofCase.TextStreamClose) { + output.WriteRawTag(138, 4); + output.WriteMessage(TextStreamClose); + } if (_unknownFields != null) { _unknownFields.WriteTo(output); } @@ -3695,32 +5715,132 @@ public void WriteTo(pb::CodedOutputStream output) { output.WriteRawTag(194, 2); output.WriteMessage(RpcMethodInvocationResponse); } - if (_unknownFields != null) { - _unknownFields.WriteTo(ref output); + if (messageCase_ == MessageOneofCase.EnableRemoteTrackPublication) { + output.WriteRawTag(202, 2); + output.WriteMessage(EnableRemoteTrackPublication); } - } - #endif - - [global::System.Diagnostics.DebuggerNonUserCodeAttribute] - [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] - public int CalculateSize() { - int size = 0; - if (messageCase_ == MessageOneofCase.Dispose) { - size += 1 + pb::CodedOutputStream.ComputeMessageSize(Dispose); + if (messageCase_ == MessageOneofCase.UpdateRemoteTrackPublicationDimension) { + output.WriteRawTag(210, 2); + output.WriteMessage(UpdateRemoteTrackPublicationDimension); } - if (messageCase_ == MessageOneofCase.Connect) { - size += 1 + pb::CodedOutputStream.ComputeMessageSize(Connect); + if (messageCase_ == MessageOneofCase.SendStreamHeader) { + output.WriteRawTag(218, 2); + output.WriteMessage(SendStreamHeader); } - if (messageCase_ == MessageOneofCase.Disconnect) { - size += 1 + pb::CodedOutputStream.ComputeMessageSize(Disconnect); + if (messageCase_ == MessageOneofCase.SendStreamChunk) { + output.WriteRawTag(226, 2); + output.WriteMessage(SendStreamChunk); } - if (messageCase_ == MessageOneofCase.PublishTrack) { - size += 1 + pb::CodedOutputStream.ComputeMessageSize(PublishTrack); + if (messageCase_ == MessageOneofCase.SendStreamTrailer) { + output.WriteRawTag(234, 2); + output.WriteMessage(SendStreamTrailer); } - if (messageCase_ == MessageOneofCase.UnpublishTrack) { - size += 1 + pb::CodedOutputStream.ComputeMessageSize(UnpublishTrack); + if (messageCase_ == MessageOneofCase.SetDataChannelBufferedAmountLowThreshold) { + output.WriteRawTag(242, 2); + output.WriteMessage(SetDataChannelBufferedAmountLowThreshold); } - if (messageCase_ == MessageOneofCase.PublishData) { + if (messageCase_ == MessageOneofCase.SetTrackSubscriptionPermissions) { + output.WriteRawTag(250, 2); + output.WriteMessage(SetTrackSubscriptionPermissions); + } + if (messageCase_ == MessageOneofCase.LoadAudioFilterPlugin) { + output.WriteRawTag(130, 3); + output.WriteMessage(LoadAudioFilterPlugin); + } + if (messageCase_ == MessageOneofCase.NewApm) { + output.WriteRawTag(138, 3); + output.WriteMessage(NewApm); + } + if (messageCase_ == MessageOneofCase.ApmProcessStream) { + output.WriteRawTag(146, 3); + output.WriteMessage(ApmProcessStream); + } + if (messageCase_ == MessageOneofCase.ApmProcessReverseStream) { + output.WriteRawTag(154, 3); + output.WriteMessage(ApmProcessReverseStream); + } + if (messageCase_ == MessageOneofCase.ApmSetStreamDelay) { + output.WriteRawTag(162, 3); + output.WriteMessage(ApmSetStreamDelay); + } + if (messageCase_ == MessageOneofCase.ByteReadIncremental) { + output.WriteRawTag(170, 3); + output.WriteMessage(ByteReadIncremental); + } + if (messageCase_ == MessageOneofCase.ByteReadAll) { + output.WriteRawTag(178, 3); + output.WriteMessage(ByteReadAll); + } + if (messageCase_ == MessageOneofCase.ByteWriteToFile) { + output.WriteRawTag(186, 3); + output.WriteMessage(ByteWriteToFile); + } + if (messageCase_ == MessageOneofCase.TextReadIncremental) { + output.WriteRawTag(194, 3); + output.WriteMessage(TextReadIncremental); + } + if (messageCase_ == MessageOneofCase.TextReadAll) { + output.WriteRawTag(202, 3); + output.WriteMessage(TextReadAll); + } + if (messageCase_ == MessageOneofCase.SendFile) { + output.WriteRawTag(210, 3); + output.WriteMessage(SendFile); + } + if (messageCase_ == MessageOneofCase.SendText) { + output.WriteRawTag(218, 3); + output.WriteMessage(SendText); + } + if (messageCase_ == MessageOneofCase.ByteStreamOpen) { + output.WriteRawTag(226, 3); + output.WriteMessage(ByteStreamOpen); + } + if (messageCase_ == MessageOneofCase.ByteStreamWrite) { + output.WriteRawTag(234, 3); + output.WriteMessage(ByteStreamWrite); + } + if (messageCase_ == MessageOneofCase.ByteStreamClose) { + output.WriteRawTag(242, 3); + output.WriteMessage(ByteStreamClose); + } + if (messageCase_ == MessageOneofCase.TextStreamOpen) { + output.WriteRawTag(250, 3); + output.WriteMessage(TextStreamOpen); + } + if (messageCase_ == MessageOneofCase.TextStreamWrite) { + output.WriteRawTag(130, 4); + output.WriteMessage(TextStreamWrite); + } + if (messageCase_ == MessageOneofCase.TextStreamClose) { + output.WriteRawTag(138, 4); + output.WriteMessage(TextStreamClose); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (messageCase_ == MessageOneofCase.Dispose) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Dispose); + } + if (messageCase_ == MessageOneofCase.Connect) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Connect); + } + if (messageCase_ == MessageOneofCase.Disconnect) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Disconnect); + } + if (messageCase_ == MessageOneofCase.PublishTrack) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(PublishTrack); + } + if (messageCase_ == MessageOneofCase.UnpublishTrack) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(UnpublishTrack); + } + if (messageCase_ == MessageOneofCase.PublishData) { size += 1 + pb::CodedOutputStream.ComputeMessageSize(PublishData); } if (messageCase_ == MessageOneofCase.SetSubscribed) { @@ -3759,6 +5879,9 @@ public int CalculateSize() { if (messageCase_ == MessageOneofCase.GetStats) { size += 2 + pb::CodedOutputStream.ComputeMessageSize(GetStats); } + if (messageCase_ == MessageOneofCase.SetTrackSubscriptionPermissions) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(SetTrackSubscriptionPermissions); + } if (messageCase_ == MessageOneofCase.NewVideoStream) { size += 2 + pb::CodedOutputStream.ComputeMessageSize(NewVideoStream); } @@ -3822,6 +5945,78 @@ public int CalculateSize() { if (messageCase_ == MessageOneofCase.RpcMethodInvocationResponse) { size += 2 + pb::CodedOutputStream.ComputeMessageSize(RpcMethodInvocationResponse); } + if (messageCase_ == MessageOneofCase.EnableRemoteTrackPublication) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(EnableRemoteTrackPublication); + } + if (messageCase_ == MessageOneofCase.UpdateRemoteTrackPublicationDimension) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(UpdateRemoteTrackPublicationDimension); + } + if (messageCase_ == MessageOneofCase.SendStreamHeader) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(SendStreamHeader); + } + if (messageCase_ == MessageOneofCase.SendStreamChunk) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(SendStreamChunk); + } + if (messageCase_ == MessageOneofCase.SendStreamTrailer) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(SendStreamTrailer); + } + if (messageCase_ == MessageOneofCase.SetDataChannelBufferedAmountLowThreshold) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(SetDataChannelBufferedAmountLowThreshold); + } + if (messageCase_ == MessageOneofCase.LoadAudioFilterPlugin) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(LoadAudioFilterPlugin); + } + if (messageCase_ == MessageOneofCase.NewApm) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(NewApm); + } + if (messageCase_ == MessageOneofCase.ApmProcessStream) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(ApmProcessStream); + } + if (messageCase_ == MessageOneofCase.ApmProcessReverseStream) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(ApmProcessReverseStream); + } + if (messageCase_ == MessageOneofCase.ApmSetStreamDelay) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(ApmSetStreamDelay); + } + if (messageCase_ == MessageOneofCase.ByteReadIncremental) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(ByteReadIncremental); + } + if (messageCase_ == MessageOneofCase.ByteReadAll) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(ByteReadAll); + } + if (messageCase_ == MessageOneofCase.ByteWriteToFile) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(ByteWriteToFile); + } + if (messageCase_ == MessageOneofCase.TextReadIncremental) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(TextReadIncremental); + } + if (messageCase_ == MessageOneofCase.TextReadAll) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(TextReadAll); + } + if (messageCase_ == MessageOneofCase.SendFile) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(SendFile); + } + if (messageCase_ == MessageOneofCase.SendText) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(SendText); + } + if (messageCase_ == MessageOneofCase.ByteStreamOpen) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(ByteStreamOpen); + } + if (messageCase_ == MessageOneofCase.ByteStreamWrite) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(ByteStreamWrite); + } + if (messageCase_ == MessageOneofCase.ByteStreamClose) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(ByteStreamClose); + } + if (messageCase_ == MessageOneofCase.TextStreamOpen) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(TextStreamOpen); + } + if (messageCase_ == MessageOneofCase.TextStreamWrite) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(TextStreamWrite); + } + if (messageCase_ == MessageOneofCase.TextStreamClose) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(TextStreamClose); + } if (_unknownFields != null) { size += _unknownFields.CalculateSize(); } @@ -3943,6 +6138,12 @@ public void MergeFrom(FfiResponse other) { } GetStats.MergeFrom(other.GetStats); break; + case MessageOneofCase.SetTrackSubscriptionPermissions: + if (SetTrackSubscriptionPermissions == null) { + SetTrackSubscriptionPermissions = new global::LiveKit.Proto.SetTrackSubscriptionPermissionsResponse(); + } + SetTrackSubscriptionPermissions.MergeFrom(other.SetTrackSubscriptionPermissions); + break; case MessageOneofCase.NewVideoStream: if (NewVideoStream == null) { NewVideoStream = new global::LiveKit.Proto.NewVideoStreamResponse(); @@ -4069,6 +6270,150 @@ public void MergeFrom(FfiResponse other) { } RpcMethodInvocationResponse.MergeFrom(other.RpcMethodInvocationResponse); break; + case MessageOneofCase.EnableRemoteTrackPublication: + if (EnableRemoteTrackPublication == null) { + EnableRemoteTrackPublication = new global::LiveKit.Proto.EnableRemoteTrackPublicationResponse(); + } + EnableRemoteTrackPublication.MergeFrom(other.EnableRemoteTrackPublication); + break; + case MessageOneofCase.UpdateRemoteTrackPublicationDimension: + if (UpdateRemoteTrackPublicationDimension == null) { + UpdateRemoteTrackPublicationDimension = new global::LiveKit.Proto.UpdateRemoteTrackPublicationDimensionResponse(); + } + UpdateRemoteTrackPublicationDimension.MergeFrom(other.UpdateRemoteTrackPublicationDimension); + break; + case MessageOneofCase.SendStreamHeader: + if (SendStreamHeader == null) { + SendStreamHeader = new global::LiveKit.Proto.SendStreamHeaderResponse(); + } + SendStreamHeader.MergeFrom(other.SendStreamHeader); + break; + case MessageOneofCase.SendStreamChunk: + if (SendStreamChunk == null) { + SendStreamChunk = new global::LiveKit.Proto.SendStreamChunkResponse(); + } + SendStreamChunk.MergeFrom(other.SendStreamChunk); + break; + case MessageOneofCase.SendStreamTrailer: + if (SendStreamTrailer == null) { + SendStreamTrailer = new global::LiveKit.Proto.SendStreamTrailerResponse(); + } + SendStreamTrailer.MergeFrom(other.SendStreamTrailer); + break; + case MessageOneofCase.SetDataChannelBufferedAmountLowThreshold: + if (SetDataChannelBufferedAmountLowThreshold == null) { + SetDataChannelBufferedAmountLowThreshold = new global::LiveKit.Proto.SetDataChannelBufferedAmountLowThresholdResponse(); + } + SetDataChannelBufferedAmountLowThreshold.MergeFrom(other.SetDataChannelBufferedAmountLowThreshold); + break; + case MessageOneofCase.LoadAudioFilterPlugin: + if (LoadAudioFilterPlugin == null) { + LoadAudioFilterPlugin = new global::LiveKit.Proto.LoadAudioFilterPluginResponse(); + } + LoadAudioFilterPlugin.MergeFrom(other.LoadAudioFilterPlugin); + break; + case MessageOneofCase.NewApm: + if (NewApm == null) { + NewApm = new global::LiveKit.Proto.NewApmResponse(); + } + NewApm.MergeFrom(other.NewApm); + break; + case MessageOneofCase.ApmProcessStream: + if (ApmProcessStream == null) { + ApmProcessStream = new global::LiveKit.Proto.ApmProcessStreamResponse(); + } + ApmProcessStream.MergeFrom(other.ApmProcessStream); + break; + case MessageOneofCase.ApmProcessReverseStream: + if (ApmProcessReverseStream == null) { + ApmProcessReverseStream = new global::LiveKit.Proto.ApmProcessReverseStreamResponse(); + } + ApmProcessReverseStream.MergeFrom(other.ApmProcessReverseStream); + break; + case MessageOneofCase.ApmSetStreamDelay: + if (ApmSetStreamDelay == null) { + ApmSetStreamDelay = new global::LiveKit.Proto.ApmSetStreamDelayResponse(); + } + ApmSetStreamDelay.MergeFrom(other.ApmSetStreamDelay); + break; + case MessageOneofCase.ByteReadIncremental: + if (ByteReadIncremental == null) { + ByteReadIncremental = new global::LiveKit.Proto.ByteStreamReaderReadIncrementalResponse(); + } + ByteReadIncremental.MergeFrom(other.ByteReadIncremental); + break; + case MessageOneofCase.ByteReadAll: + if (ByteReadAll == null) { + ByteReadAll = new global::LiveKit.Proto.ByteStreamReaderReadAllResponse(); + } + ByteReadAll.MergeFrom(other.ByteReadAll); + break; + case MessageOneofCase.ByteWriteToFile: + if (ByteWriteToFile == null) { + ByteWriteToFile = new global::LiveKit.Proto.ByteStreamReaderWriteToFileResponse(); + } + ByteWriteToFile.MergeFrom(other.ByteWriteToFile); + break; + case MessageOneofCase.TextReadIncremental: + if (TextReadIncremental == null) { + TextReadIncremental = new global::LiveKit.Proto.TextStreamReaderReadIncrementalResponse(); + } + TextReadIncremental.MergeFrom(other.TextReadIncremental); + break; + case MessageOneofCase.TextReadAll: + if (TextReadAll == null) { + TextReadAll = new global::LiveKit.Proto.TextStreamReaderReadAllResponse(); + } + TextReadAll.MergeFrom(other.TextReadAll); + break; + case MessageOneofCase.SendFile: + if (SendFile == null) { + SendFile = new global::LiveKit.Proto.StreamSendFileResponse(); + } + SendFile.MergeFrom(other.SendFile); + break; + case MessageOneofCase.SendText: + if (SendText == null) { + SendText = new global::LiveKit.Proto.StreamSendTextResponse(); + } + SendText.MergeFrom(other.SendText); + break; + case MessageOneofCase.ByteStreamOpen: + if (ByteStreamOpen == null) { + ByteStreamOpen = new global::LiveKit.Proto.ByteStreamOpenResponse(); + } + ByteStreamOpen.MergeFrom(other.ByteStreamOpen); + break; + case MessageOneofCase.ByteStreamWrite: + if (ByteStreamWrite == null) { + ByteStreamWrite = new global::LiveKit.Proto.ByteStreamWriterWriteResponse(); + } + ByteStreamWrite.MergeFrom(other.ByteStreamWrite); + break; + case MessageOneofCase.ByteStreamClose: + if (ByteStreamClose == null) { + ByteStreamClose = new global::LiveKit.Proto.ByteStreamWriterCloseResponse(); + } + ByteStreamClose.MergeFrom(other.ByteStreamClose); + break; + case MessageOneofCase.TextStreamOpen: + if (TextStreamOpen == null) { + TextStreamOpen = new global::LiveKit.Proto.TextStreamOpenResponse(); + } + TextStreamOpen.MergeFrom(other.TextStreamOpen); + break; + case MessageOneofCase.TextStreamWrite: + if (TextStreamWrite == null) { + TextStreamWrite = new global::LiveKit.Proto.TextStreamWriterWriteResponse(); + } + TextStreamWrite.MergeFrom(other.TextStreamWrite); + break; + case MessageOneofCase.TextStreamClose: + if (TextStreamClose == null) { + TextStreamClose = new global::LiveKit.Proto.TextStreamWriterCloseResponse(); + } + TextStreamClose.MergeFrom(other.TextStreamClose); + break; } _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); @@ -4441,6 +6786,231 @@ public void MergeFrom(pb::CodedInputStream input) { RpcMethodInvocationResponse = subBuilder; break; } + case 330: { + global::LiveKit.Proto.EnableRemoteTrackPublicationResponse subBuilder = new global::LiveKit.Proto.EnableRemoteTrackPublicationResponse(); + if (messageCase_ == MessageOneofCase.EnableRemoteTrackPublication) { + subBuilder.MergeFrom(EnableRemoteTrackPublication); + } + input.ReadMessage(subBuilder); + EnableRemoteTrackPublication = subBuilder; + break; + } + case 338: { + global::LiveKit.Proto.UpdateRemoteTrackPublicationDimensionResponse subBuilder = new global::LiveKit.Proto.UpdateRemoteTrackPublicationDimensionResponse(); + if (messageCase_ == MessageOneofCase.UpdateRemoteTrackPublicationDimension) { + subBuilder.MergeFrom(UpdateRemoteTrackPublicationDimension); + } + input.ReadMessage(subBuilder); + UpdateRemoteTrackPublicationDimension = subBuilder; + break; + } + case 346: { + global::LiveKit.Proto.SendStreamHeaderResponse subBuilder = new global::LiveKit.Proto.SendStreamHeaderResponse(); + if (messageCase_ == MessageOneofCase.SendStreamHeader) { + subBuilder.MergeFrom(SendStreamHeader); + } + input.ReadMessage(subBuilder); + SendStreamHeader = subBuilder; + break; + } + case 354: { + global::LiveKit.Proto.SendStreamChunkResponse subBuilder = new global::LiveKit.Proto.SendStreamChunkResponse(); + if (messageCase_ == MessageOneofCase.SendStreamChunk) { + subBuilder.MergeFrom(SendStreamChunk); + } + input.ReadMessage(subBuilder); + SendStreamChunk = subBuilder; + break; + } + case 362: { + global::LiveKit.Proto.SendStreamTrailerResponse subBuilder = new global::LiveKit.Proto.SendStreamTrailerResponse(); + if (messageCase_ == MessageOneofCase.SendStreamTrailer) { + subBuilder.MergeFrom(SendStreamTrailer); + } + input.ReadMessage(subBuilder); + SendStreamTrailer = subBuilder; + break; + } + case 370: { + global::LiveKit.Proto.SetDataChannelBufferedAmountLowThresholdResponse subBuilder = new global::LiveKit.Proto.SetDataChannelBufferedAmountLowThresholdResponse(); + if (messageCase_ == MessageOneofCase.SetDataChannelBufferedAmountLowThreshold) { + subBuilder.MergeFrom(SetDataChannelBufferedAmountLowThreshold); + } + input.ReadMessage(subBuilder); + SetDataChannelBufferedAmountLowThreshold = subBuilder; + break; + } + case 378: { + global::LiveKit.Proto.SetTrackSubscriptionPermissionsResponse subBuilder = new global::LiveKit.Proto.SetTrackSubscriptionPermissionsResponse(); + if (messageCase_ == MessageOneofCase.SetTrackSubscriptionPermissions) { + subBuilder.MergeFrom(SetTrackSubscriptionPermissions); + } + input.ReadMessage(subBuilder); + SetTrackSubscriptionPermissions = subBuilder; + break; + } + case 386: { + global::LiveKit.Proto.LoadAudioFilterPluginResponse subBuilder = new global::LiveKit.Proto.LoadAudioFilterPluginResponse(); + if (messageCase_ == MessageOneofCase.LoadAudioFilterPlugin) { + subBuilder.MergeFrom(LoadAudioFilterPlugin); + } + input.ReadMessage(subBuilder); + LoadAudioFilterPlugin = subBuilder; + break; + } + case 394: { + global::LiveKit.Proto.NewApmResponse subBuilder = new global::LiveKit.Proto.NewApmResponse(); + if (messageCase_ == MessageOneofCase.NewApm) { + subBuilder.MergeFrom(NewApm); + } + input.ReadMessage(subBuilder); + NewApm = subBuilder; + break; + } + case 402: { + global::LiveKit.Proto.ApmProcessStreamResponse subBuilder = new global::LiveKit.Proto.ApmProcessStreamResponse(); + if (messageCase_ == MessageOneofCase.ApmProcessStream) { + subBuilder.MergeFrom(ApmProcessStream); + } + input.ReadMessage(subBuilder); + ApmProcessStream = subBuilder; + break; + } + case 410: { + global::LiveKit.Proto.ApmProcessReverseStreamResponse subBuilder = new global::LiveKit.Proto.ApmProcessReverseStreamResponse(); + if (messageCase_ == MessageOneofCase.ApmProcessReverseStream) { + subBuilder.MergeFrom(ApmProcessReverseStream); + } + input.ReadMessage(subBuilder); + ApmProcessReverseStream = subBuilder; + break; + } + case 418: { + global::LiveKit.Proto.ApmSetStreamDelayResponse subBuilder = new global::LiveKit.Proto.ApmSetStreamDelayResponse(); + if (messageCase_ == MessageOneofCase.ApmSetStreamDelay) { + subBuilder.MergeFrom(ApmSetStreamDelay); + } + input.ReadMessage(subBuilder); + ApmSetStreamDelay = subBuilder; + break; + } + case 426: { + global::LiveKit.Proto.ByteStreamReaderReadIncrementalResponse subBuilder = new global::LiveKit.Proto.ByteStreamReaderReadIncrementalResponse(); + if (messageCase_ == MessageOneofCase.ByteReadIncremental) { + subBuilder.MergeFrom(ByteReadIncremental); + } + input.ReadMessage(subBuilder); + ByteReadIncremental = subBuilder; + break; + } + case 434: { + global::LiveKit.Proto.ByteStreamReaderReadAllResponse subBuilder = new global::LiveKit.Proto.ByteStreamReaderReadAllResponse(); + if (messageCase_ == MessageOneofCase.ByteReadAll) { + subBuilder.MergeFrom(ByteReadAll); + } + input.ReadMessage(subBuilder); + ByteReadAll = subBuilder; + break; + } + case 442: { + global::LiveKit.Proto.ByteStreamReaderWriteToFileResponse subBuilder = new global::LiveKit.Proto.ByteStreamReaderWriteToFileResponse(); + if (messageCase_ == MessageOneofCase.ByteWriteToFile) { + subBuilder.MergeFrom(ByteWriteToFile); + } + input.ReadMessage(subBuilder); + ByteWriteToFile = subBuilder; + break; + } + case 450: { + global::LiveKit.Proto.TextStreamReaderReadIncrementalResponse subBuilder = new global::LiveKit.Proto.TextStreamReaderReadIncrementalResponse(); + if (messageCase_ == MessageOneofCase.TextReadIncremental) { + subBuilder.MergeFrom(TextReadIncremental); + } + input.ReadMessage(subBuilder); + TextReadIncremental = subBuilder; + break; + } + case 458: { + global::LiveKit.Proto.TextStreamReaderReadAllResponse subBuilder = new global::LiveKit.Proto.TextStreamReaderReadAllResponse(); + if (messageCase_ == MessageOneofCase.TextReadAll) { + subBuilder.MergeFrom(TextReadAll); + } + input.ReadMessage(subBuilder); + TextReadAll = subBuilder; + break; + } + case 466: { + global::LiveKit.Proto.StreamSendFileResponse subBuilder = new global::LiveKit.Proto.StreamSendFileResponse(); + if (messageCase_ == MessageOneofCase.SendFile) { + subBuilder.MergeFrom(SendFile); + } + input.ReadMessage(subBuilder); + SendFile = subBuilder; + break; + } + case 474: { + global::LiveKit.Proto.StreamSendTextResponse subBuilder = new global::LiveKit.Proto.StreamSendTextResponse(); + if (messageCase_ == MessageOneofCase.SendText) { + subBuilder.MergeFrom(SendText); + } + input.ReadMessage(subBuilder); + SendText = subBuilder; + break; + } + case 482: { + global::LiveKit.Proto.ByteStreamOpenResponse subBuilder = new global::LiveKit.Proto.ByteStreamOpenResponse(); + if (messageCase_ == MessageOneofCase.ByteStreamOpen) { + subBuilder.MergeFrom(ByteStreamOpen); + } + input.ReadMessage(subBuilder); + ByteStreamOpen = subBuilder; + break; + } + case 490: { + global::LiveKit.Proto.ByteStreamWriterWriteResponse subBuilder = new global::LiveKit.Proto.ByteStreamWriterWriteResponse(); + if (messageCase_ == MessageOneofCase.ByteStreamWrite) { + subBuilder.MergeFrom(ByteStreamWrite); + } + input.ReadMessage(subBuilder); + ByteStreamWrite = subBuilder; + break; + } + case 498: { + global::LiveKit.Proto.ByteStreamWriterCloseResponse subBuilder = new global::LiveKit.Proto.ByteStreamWriterCloseResponse(); + if (messageCase_ == MessageOneofCase.ByteStreamClose) { + subBuilder.MergeFrom(ByteStreamClose); + } + input.ReadMessage(subBuilder); + ByteStreamClose = subBuilder; + break; + } + case 506: { + global::LiveKit.Proto.TextStreamOpenResponse subBuilder = new global::LiveKit.Proto.TextStreamOpenResponse(); + if (messageCase_ == MessageOneofCase.TextStreamOpen) { + subBuilder.MergeFrom(TextStreamOpen); + } + input.ReadMessage(subBuilder); + TextStreamOpen = subBuilder; + break; + } + case 514: { + global::LiveKit.Proto.TextStreamWriterWriteResponse subBuilder = new global::LiveKit.Proto.TextStreamWriterWriteResponse(); + if (messageCase_ == MessageOneofCase.TextStreamWrite) { + subBuilder.MergeFrom(TextStreamWrite); + } + input.ReadMessage(subBuilder); + TextStreamWrite = subBuilder; + break; + } + case 522: { + global::LiveKit.Proto.TextStreamWriterCloseResponse subBuilder = new global::LiveKit.Proto.TextStreamWriterCloseResponse(); + if (messageCase_ == MessageOneofCase.TextStreamClose) { + subBuilder.MergeFrom(TextStreamClose); + } + input.ReadMessage(subBuilder); + TextStreamClose = subBuilder; + break; + } } } #endif @@ -4664,151 +7234,376 @@ public void MergeFrom(pb::CodedInputStream input) { subBuilder.MergeFrom(VideoStreamFromParticipant); } input.ReadMessage(subBuilder); - VideoStreamFromParticipant = subBuilder; + VideoStreamFromParticipant = subBuilder; + break; + } + case 202: { + global::LiveKit.Proto.NewAudioStreamResponse subBuilder = new global::LiveKit.Proto.NewAudioStreamResponse(); + if (messageCase_ == MessageOneofCase.NewAudioStream) { + subBuilder.MergeFrom(NewAudioStream); + } + input.ReadMessage(subBuilder); + NewAudioStream = subBuilder; + break; + } + case 210: { + global::LiveKit.Proto.NewAudioSourceResponse subBuilder = new global::LiveKit.Proto.NewAudioSourceResponse(); + if (messageCase_ == MessageOneofCase.NewAudioSource) { + subBuilder.MergeFrom(NewAudioSource); + } + input.ReadMessage(subBuilder); + NewAudioSource = subBuilder; + break; + } + case 218: { + global::LiveKit.Proto.CaptureAudioFrameResponse subBuilder = new global::LiveKit.Proto.CaptureAudioFrameResponse(); + if (messageCase_ == MessageOneofCase.CaptureAudioFrame) { + subBuilder.MergeFrom(CaptureAudioFrame); + } + input.ReadMessage(subBuilder); + CaptureAudioFrame = subBuilder; + break; + } + case 226: { + global::LiveKit.Proto.ClearAudioBufferResponse subBuilder = new global::LiveKit.Proto.ClearAudioBufferResponse(); + if (messageCase_ == MessageOneofCase.ClearAudioBuffer) { + subBuilder.MergeFrom(ClearAudioBuffer); + } + input.ReadMessage(subBuilder); + ClearAudioBuffer = subBuilder; + break; + } + case 234: { + global::LiveKit.Proto.NewAudioResamplerResponse subBuilder = new global::LiveKit.Proto.NewAudioResamplerResponse(); + if (messageCase_ == MessageOneofCase.NewAudioResampler) { + subBuilder.MergeFrom(NewAudioResampler); + } + input.ReadMessage(subBuilder); + NewAudioResampler = subBuilder; + break; + } + case 242: { + global::LiveKit.Proto.RemixAndResampleResponse subBuilder = new global::LiveKit.Proto.RemixAndResampleResponse(); + if (messageCase_ == MessageOneofCase.RemixAndResample) { + subBuilder.MergeFrom(RemixAndResample); + } + input.ReadMessage(subBuilder); + RemixAndResample = subBuilder; + break; + } + case 250: { + global::LiveKit.Proto.AudioStreamFromParticipantResponse subBuilder = new global::LiveKit.Proto.AudioStreamFromParticipantResponse(); + if (messageCase_ == MessageOneofCase.AudioStreamFromParticipant) { + subBuilder.MergeFrom(AudioStreamFromParticipant); + } + input.ReadMessage(subBuilder); + AudioStreamFromParticipant = subBuilder; + break; + } + case 258: { + global::LiveKit.Proto.E2eeResponse subBuilder = new global::LiveKit.Proto.E2eeResponse(); + if (messageCase_ == MessageOneofCase.E2Ee) { + subBuilder.MergeFrom(E2Ee); + } + input.ReadMessage(subBuilder); + E2Ee = subBuilder; + break; + } + case 266: { + global::LiveKit.Proto.NewSoxResamplerResponse subBuilder = new global::LiveKit.Proto.NewSoxResamplerResponse(); + if (messageCase_ == MessageOneofCase.NewSoxResampler) { + subBuilder.MergeFrom(NewSoxResampler); + } + input.ReadMessage(subBuilder); + NewSoxResampler = subBuilder; + break; + } + case 274: { + global::LiveKit.Proto.PushSoxResamplerResponse subBuilder = new global::LiveKit.Proto.PushSoxResamplerResponse(); + if (messageCase_ == MessageOneofCase.PushSoxResampler) { + subBuilder.MergeFrom(PushSoxResampler); + } + input.ReadMessage(subBuilder); + PushSoxResampler = subBuilder; + break; + } + case 282: { + global::LiveKit.Proto.FlushSoxResamplerResponse subBuilder = new global::LiveKit.Proto.FlushSoxResamplerResponse(); + if (messageCase_ == MessageOneofCase.FlushSoxResampler) { + subBuilder.MergeFrom(FlushSoxResampler); + } + input.ReadMessage(subBuilder); + FlushSoxResampler = subBuilder; + break; + } + case 290: { + global::LiveKit.Proto.SendChatMessageResponse subBuilder = new global::LiveKit.Proto.SendChatMessageResponse(); + if (messageCase_ == MessageOneofCase.SendChatMessage) { + subBuilder.MergeFrom(SendChatMessage); + } + input.ReadMessage(subBuilder); + SendChatMessage = subBuilder; + break; + } + case 298: { + global::LiveKit.Proto.PerformRpcResponse subBuilder = new global::LiveKit.Proto.PerformRpcResponse(); + if (messageCase_ == MessageOneofCase.PerformRpc) { + subBuilder.MergeFrom(PerformRpc); + } + input.ReadMessage(subBuilder); + PerformRpc = subBuilder; + break; + } + case 306: { + global::LiveKit.Proto.RegisterRpcMethodResponse subBuilder = new global::LiveKit.Proto.RegisterRpcMethodResponse(); + if (messageCase_ == MessageOneofCase.RegisterRpcMethod) { + subBuilder.MergeFrom(RegisterRpcMethod); + } + input.ReadMessage(subBuilder); + RegisterRpcMethod = subBuilder; + break; + } + case 314: { + global::LiveKit.Proto.UnregisterRpcMethodResponse subBuilder = new global::LiveKit.Proto.UnregisterRpcMethodResponse(); + if (messageCase_ == MessageOneofCase.UnregisterRpcMethod) { + subBuilder.MergeFrom(UnregisterRpcMethod); + } + input.ReadMessage(subBuilder); + UnregisterRpcMethod = subBuilder; + break; + } + case 322: { + global::LiveKit.Proto.RpcMethodInvocationResponseResponse subBuilder = new global::LiveKit.Proto.RpcMethodInvocationResponseResponse(); + if (messageCase_ == MessageOneofCase.RpcMethodInvocationResponse) { + subBuilder.MergeFrom(RpcMethodInvocationResponse); + } + input.ReadMessage(subBuilder); + RpcMethodInvocationResponse = subBuilder; + break; + } + case 330: { + global::LiveKit.Proto.EnableRemoteTrackPublicationResponse subBuilder = new global::LiveKit.Proto.EnableRemoteTrackPublicationResponse(); + if (messageCase_ == MessageOneofCase.EnableRemoteTrackPublication) { + subBuilder.MergeFrom(EnableRemoteTrackPublication); + } + input.ReadMessage(subBuilder); + EnableRemoteTrackPublication = subBuilder; + break; + } + case 338: { + global::LiveKit.Proto.UpdateRemoteTrackPublicationDimensionResponse subBuilder = new global::LiveKit.Proto.UpdateRemoteTrackPublicationDimensionResponse(); + if (messageCase_ == MessageOneofCase.UpdateRemoteTrackPublicationDimension) { + subBuilder.MergeFrom(UpdateRemoteTrackPublicationDimension); + } + input.ReadMessage(subBuilder); + UpdateRemoteTrackPublicationDimension = subBuilder; + break; + } + case 346: { + global::LiveKit.Proto.SendStreamHeaderResponse subBuilder = new global::LiveKit.Proto.SendStreamHeaderResponse(); + if (messageCase_ == MessageOneofCase.SendStreamHeader) { + subBuilder.MergeFrom(SendStreamHeader); + } + input.ReadMessage(subBuilder); + SendStreamHeader = subBuilder; + break; + } + case 354: { + global::LiveKit.Proto.SendStreamChunkResponse subBuilder = new global::LiveKit.Proto.SendStreamChunkResponse(); + if (messageCase_ == MessageOneofCase.SendStreamChunk) { + subBuilder.MergeFrom(SendStreamChunk); + } + input.ReadMessage(subBuilder); + SendStreamChunk = subBuilder; + break; + } + case 362: { + global::LiveKit.Proto.SendStreamTrailerResponse subBuilder = new global::LiveKit.Proto.SendStreamTrailerResponse(); + if (messageCase_ == MessageOneofCase.SendStreamTrailer) { + subBuilder.MergeFrom(SendStreamTrailer); + } + input.ReadMessage(subBuilder); + SendStreamTrailer = subBuilder; + break; + } + case 370: { + global::LiveKit.Proto.SetDataChannelBufferedAmountLowThresholdResponse subBuilder = new global::LiveKit.Proto.SetDataChannelBufferedAmountLowThresholdResponse(); + if (messageCase_ == MessageOneofCase.SetDataChannelBufferedAmountLowThreshold) { + subBuilder.MergeFrom(SetDataChannelBufferedAmountLowThreshold); + } + input.ReadMessage(subBuilder); + SetDataChannelBufferedAmountLowThreshold = subBuilder; + break; + } + case 378: { + global::LiveKit.Proto.SetTrackSubscriptionPermissionsResponse subBuilder = new global::LiveKit.Proto.SetTrackSubscriptionPermissionsResponse(); + if (messageCase_ == MessageOneofCase.SetTrackSubscriptionPermissions) { + subBuilder.MergeFrom(SetTrackSubscriptionPermissions); + } + input.ReadMessage(subBuilder); + SetTrackSubscriptionPermissions = subBuilder; + break; + } + case 386: { + global::LiveKit.Proto.LoadAudioFilterPluginResponse subBuilder = new global::LiveKit.Proto.LoadAudioFilterPluginResponse(); + if (messageCase_ == MessageOneofCase.LoadAudioFilterPlugin) { + subBuilder.MergeFrom(LoadAudioFilterPlugin); + } + input.ReadMessage(subBuilder); + LoadAudioFilterPlugin = subBuilder; + break; + } + case 394: { + global::LiveKit.Proto.NewApmResponse subBuilder = new global::LiveKit.Proto.NewApmResponse(); + if (messageCase_ == MessageOneofCase.NewApm) { + subBuilder.MergeFrom(NewApm); + } + input.ReadMessage(subBuilder); + NewApm = subBuilder; break; } - case 202: { - global::LiveKit.Proto.NewAudioStreamResponse subBuilder = new global::LiveKit.Proto.NewAudioStreamResponse(); - if (messageCase_ == MessageOneofCase.NewAudioStream) { - subBuilder.MergeFrom(NewAudioStream); + case 402: { + global::LiveKit.Proto.ApmProcessStreamResponse subBuilder = new global::LiveKit.Proto.ApmProcessStreamResponse(); + if (messageCase_ == MessageOneofCase.ApmProcessStream) { + subBuilder.MergeFrom(ApmProcessStream); } input.ReadMessage(subBuilder); - NewAudioStream = subBuilder; + ApmProcessStream = subBuilder; break; } - case 210: { - global::LiveKit.Proto.NewAudioSourceResponse subBuilder = new global::LiveKit.Proto.NewAudioSourceResponse(); - if (messageCase_ == MessageOneofCase.NewAudioSource) { - subBuilder.MergeFrom(NewAudioSource); + case 410: { + global::LiveKit.Proto.ApmProcessReverseStreamResponse subBuilder = new global::LiveKit.Proto.ApmProcessReverseStreamResponse(); + if (messageCase_ == MessageOneofCase.ApmProcessReverseStream) { + subBuilder.MergeFrom(ApmProcessReverseStream); } input.ReadMessage(subBuilder); - NewAudioSource = subBuilder; + ApmProcessReverseStream = subBuilder; break; } - case 218: { - global::LiveKit.Proto.CaptureAudioFrameResponse subBuilder = new global::LiveKit.Proto.CaptureAudioFrameResponse(); - if (messageCase_ == MessageOneofCase.CaptureAudioFrame) { - subBuilder.MergeFrom(CaptureAudioFrame); + case 418: { + global::LiveKit.Proto.ApmSetStreamDelayResponse subBuilder = new global::LiveKit.Proto.ApmSetStreamDelayResponse(); + if (messageCase_ == MessageOneofCase.ApmSetStreamDelay) { + subBuilder.MergeFrom(ApmSetStreamDelay); } input.ReadMessage(subBuilder); - CaptureAudioFrame = subBuilder; + ApmSetStreamDelay = subBuilder; break; } - case 226: { - global::LiveKit.Proto.ClearAudioBufferResponse subBuilder = new global::LiveKit.Proto.ClearAudioBufferResponse(); - if (messageCase_ == MessageOneofCase.ClearAudioBuffer) { - subBuilder.MergeFrom(ClearAudioBuffer); + case 426: { + global::LiveKit.Proto.ByteStreamReaderReadIncrementalResponse subBuilder = new global::LiveKit.Proto.ByteStreamReaderReadIncrementalResponse(); + if (messageCase_ == MessageOneofCase.ByteReadIncremental) { + subBuilder.MergeFrom(ByteReadIncremental); } input.ReadMessage(subBuilder); - ClearAudioBuffer = subBuilder; + ByteReadIncremental = subBuilder; break; } - case 234: { - global::LiveKit.Proto.NewAudioResamplerResponse subBuilder = new global::LiveKit.Proto.NewAudioResamplerResponse(); - if (messageCase_ == MessageOneofCase.NewAudioResampler) { - subBuilder.MergeFrom(NewAudioResampler); + case 434: { + global::LiveKit.Proto.ByteStreamReaderReadAllResponse subBuilder = new global::LiveKit.Proto.ByteStreamReaderReadAllResponse(); + if (messageCase_ == MessageOneofCase.ByteReadAll) { + subBuilder.MergeFrom(ByteReadAll); } input.ReadMessage(subBuilder); - NewAudioResampler = subBuilder; + ByteReadAll = subBuilder; break; } - case 242: { - global::LiveKit.Proto.RemixAndResampleResponse subBuilder = new global::LiveKit.Proto.RemixAndResampleResponse(); - if (messageCase_ == MessageOneofCase.RemixAndResample) { - subBuilder.MergeFrom(RemixAndResample); + case 442: { + global::LiveKit.Proto.ByteStreamReaderWriteToFileResponse subBuilder = new global::LiveKit.Proto.ByteStreamReaderWriteToFileResponse(); + if (messageCase_ == MessageOneofCase.ByteWriteToFile) { + subBuilder.MergeFrom(ByteWriteToFile); } input.ReadMessage(subBuilder); - RemixAndResample = subBuilder; + ByteWriteToFile = subBuilder; break; } - case 250: { - global::LiveKit.Proto.AudioStreamFromParticipantResponse subBuilder = new global::LiveKit.Proto.AudioStreamFromParticipantResponse(); - if (messageCase_ == MessageOneofCase.AudioStreamFromParticipant) { - subBuilder.MergeFrom(AudioStreamFromParticipant); + case 450: { + global::LiveKit.Proto.TextStreamReaderReadIncrementalResponse subBuilder = new global::LiveKit.Proto.TextStreamReaderReadIncrementalResponse(); + if (messageCase_ == MessageOneofCase.TextReadIncremental) { + subBuilder.MergeFrom(TextReadIncremental); } input.ReadMessage(subBuilder); - AudioStreamFromParticipant = subBuilder; + TextReadIncremental = subBuilder; break; } - case 258: { - global::LiveKit.Proto.E2eeResponse subBuilder = new global::LiveKit.Proto.E2eeResponse(); - if (messageCase_ == MessageOneofCase.E2Ee) { - subBuilder.MergeFrom(E2Ee); + case 458: { + global::LiveKit.Proto.TextStreamReaderReadAllResponse subBuilder = new global::LiveKit.Proto.TextStreamReaderReadAllResponse(); + if (messageCase_ == MessageOneofCase.TextReadAll) { + subBuilder.MergeFrom(TextReadAll); } input.ReadMessage(subBuilder); - E2Ee = subBuilder; + TextReadAll = subBuilder; break; } - case 266: { - global::LiveKit.Proto.NewSoxResamplerResponse subBuilder = new global::LiveKit.Proto.NewSoxResamplerResponse(); - if (messageCase_ == MessageOneofCase.NewSoxResampler) { - subBuilder.MergeFrom(NewSoxResampler); + case 466: { + global::LiveKit.Proto.StreamSendFileResponse subBuilder = new global::LiveKit.Proto.StreamSendFileResponse(); + if (messageCase_ == MessageOneofCase.SendFile) { + subBuilder.MergeFrom(SendFile); } input.ReadMessage(subBuilder); - NewSoxResampler = subBuilder; + SendFile = subBuilder; break; } - case 274: { - global::LiveKit.Proto.PushSoxResamplerResponse subBuilder = new global::LiveKit.Proto.PushSoxResamplerResponse(); - if (messageCase_ == MessageOneofCase.PushSoxResampler) { - subBuilder.MergeFrom(PushSoxResampler); + case 474: { + global::LiveKit.Proto.StreamSendTextResponse subBuilder = new global::LiveKit.Proto.StreamSendTextResponse(); + if (messageCase_ == MessageOneofCase.SendText) { + subBuilder.MergeFrom(SendText); } input.ReadMessage(subBuilder); - PushSoxResampler = subBuilder; + SendText = subBuilder; break; } - case 282: { - global::LiveKit.Proto.FlushSoxResamplerResponse subBuilder = new global::LiveKit.Proto.FlushSoxResamplerResponse(); - if (messageCase_ == MessageOneofCase.FlushSoxResampler) { - subBuilder.MergeFrom(FlushSoxResampler); + case 482: { + global::LiveKit.Proto.ByteStreamOpenResponse subBuilder = new global::LiveKit.Proto.ByteStreamOpenResponse(); + if (messageCase_ == MessageOneofCase.ByteStreamOpen) { + subBuilder.MergeFrom(ByteStreamOpen); } input.ReadMessage(subBuilder); - FlushSoxResampler = subBuilder; + ByteStreamOpen = subBuilder; break; } - case 290: { - global::LiveKit.Proto.SendChatMessageResponse subBuilder = new global::LiveKit.Proto.SendChatMessageResponse(); - if (messageCase_ == MessageOneofCase.SendChatMessage) { - subBuilder.MergeFrom(SendChatMessage); + case 490: { + global::LiveKit.Proto.ByteStreamWriterWriteResponse subBuilder = new global::LiveKit.Proto.ByteStreamWriterWriteResponse(); + if (messageCase_ == MessageOneofCase.ByteStreamWrite) { + subBuilder.MergeFrom(ByteStreamWrite); } input.ReadMessage(subBuilder); - SendChatMessage = subBuilder; + ByteStreamWrite = subBuilder; break; } - case 298: { - global::LiveKit.Proto.PerformRpcResponse subBuilder = new global::LiveKit.Proto.PerformRpcResponse(); - if (messageCase_ == MessageOneofCase.PerformRpc) { - subBuilder.MergeFrom(PerformRpc); + case 498: { + global::LiveKit.Proto.ByteStreamWriterCloseResponse subBuilder = new global::LiveKit.Proto.ByteStreamWriterCloseResponse(); + if (messageCase_ == MessageOneofCase.ByteStreamClose) { + subBuilder.MergeFrom(ByteStreamClose); } input.ReadMessage(subBuilder); - PerformRpc = subBuilder; + ByteStreamClose = subBuilder; break; } - case 306: { - global::LiveKit.Proto.RegisterRpcMethodResponse subBuilder = new global::LiveKit.Proto.RegisterRpcMethodResponse(); - if (messageCase_ == MessageOneofCase.RegisterRpcMethod) { - subBuilder.MergeFrom(RegisterRpcMethod); + case 506: { + global::LiveKit.Proto.TextStreamOpenResponse subBuilder = new global::LiveKit.Proto.TextStreamOpenResponse(); + if (messageCase_ == MessageOneofCase.TextStreamOpen) { + subBuilder.MergeFrom(TextStreamOpen); } input.ReadMessage(subBuilder); - RegisterRpcMethod = subBuilder; + TextStreamOpen = subBuilder; break; } - case 314: { - global::LiveKit.Proto.UnregisterRpcMethodResponse subBuilder = new global::LiveKit.Proto.UnregisterRpcMethodResponse(); - if (messageCase_ == MessageOneofCase.UnregisterRpcMethod) { - subBuilder.MergeFrom(UnregisterRpcMethod); + case 514: { + global::LiveKit.Proto.TextStreamWriterWriteResponse subBuilder = new global::LiveKit.Proto.TextStreamWriterWriteResponse(); + if (messageCase_ == MessageOneofCase.TextStreamWrite) { + subBuilder.MergeFrom(TextStreamWrite); } input.ReadMessage(subBuilder); - UnregisterRpcMethod = subBuilder; + TextStreamWrite = subBuilder; break; } - case 322: { - global::LiveKit.Proto.RpcMethodInvocationResponseResponse subBuilder = new global::LiveKit.Proto.RpcMethodInvocationResponseResponse(); - if (messageCase_ == MessageOneofCase.RpcMethodInvocationResponse) { - subBuilder.MergeFrom(RpcMethodInvocationResponse); + case 522: { + global::LiveKit.Proto.TextStreamWriterCloseResponse subBuilder = new global::LiveKit.Proto.TextStreamWriterCloseResponse(); + if (messageCase_ == MessageOneofCase.TextStreamClose) { + subBuilder.MergeFrom(TextStreamClose); } input.ReadMessage(subBuilder); - RpcMethodInvocationResponse = subBuilder; + TextStreamClose = subBuilder; break; } } @@ -4928,6 +7723,54 @@ public FfiEvent(FfiEvent other) : this() { case MessageOneofCase.RpcMethodInvocation: RpcMethodInvocation = other.RpcMethodInvocation.Clone(); break; + case MessageOneofCase.SendStreamHeader: + SendStreamHeader = other.SendStreamHeader.Clone(); + break; + case MessageOneofCase.SendStreamChunk: + SendStreamChunk = other.SendStreamChunk.Clone(); + break; + case MessageOneofCase.SendStreamTrailer: + SendStreamTrailer = other.SendStreamTrailer.Clone(); + break; + case MessageOneofCase.ByteStreamReaderEvent: + ByteStreamReaderEvent = other.ByteStreamReaderEvent.Clone(); + break; + case MessageOneofCase.ByteStreamReaderReadAll: + ByteStreamReaderReadAll = other.ByteStreamReaderReadAll.Clone(); + break; + case MessageOneofCase.ByteStreamReaderWriteToFile: + ByteStreamReaderWriteToFile = other.ByteStreamReaderWriteToFile.Clone(); + break; + case MessageOneofCase.ByteStreamOpen: + ByteStreamOpen = other.ByteStreamOpen.Clone(); + break; + case MessageOneofCase.ByteStreamWriterWrite: + ByteStreamWriterWrite = other.ByteStreamWriterWrite.Clone(); + break; + case MessageOneofCase.ByteStreamWriterClose: + ByteStreamWriterClose = other.ByteStreamWriterClose.Clone(); + break; + case MessageOneofCase.SendFile: + SendFile = other.SendFile.Clone(); + break; + case MessageOneofCase.TextStreamReaderEvent: + TextStreamReaderEvent = other.TextStreamReaderEvent.Clone(); + break; + case MessageOneofCase.TextStreamReaderReadAll: + TextStreamReaderReadAll = other.TextStreamReaderReadAll.Clone(); + break; + case MessageOneofCase.TextStreamOpen: + TextStreamOpen = other.TextStreamOpen.Clone(); + break; + case MessageOneofCase.TextStreamWriterWrite: + TextStreamWriterWrite = other.TextStreamWriterWrite.Clone(); + break; + case MessageOneofCase.TextStreamWriterClose: + TextStreamWriterClose = other.TextStreamWriterClose.Clone(); + break; + case MessageOneofCase.SendText: + SendText = other.SendText.Clone(); + break; } _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); @@ -5215,6 +8058,204 @@ public FfiEvent Clone() { } } + /// Field number for the "send_stream_header" field. + public const int SendStreamHeaderFieldNumber = 25; + /// + /// Data Streams (low level) + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.SendStreamHeaderCallback SendStreamHeader { + get { return messageCase_ == MessageOneofCase.SendStreamHeader ? (global::LiveKit.Proto.SendStreamHeaderCallback) message_ : null; } + set { + message_ = value; + messageCase_ = value == null ? MessageOneofCase.None : MessageOneofCase.SendStreamHeader; + } + } + + /// Field number for the "send_stream_chunk" field. + public const int SendStreamChunkFieldNumber = 26; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.SendStreamChunkCallback SendStreamChunk { + get { return messageCase_ == MessageOneofCase.SendStreamChunk ? (global::LiveKit.Proto.SendStreamChunkCallback) message_ : null; } + set { + message_ = value; + messageCase_ = value == null ? MessageOneofCase.None : MessageOneofCase.SendStreamChunk; + } + } + + /// Field number for the "send_stream_trailer" field. + public const int SendStreamTrailerFieldNumber = 27; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.SendStreamTrailerCallback SendStreamTrailer { + get { return messageCase_ == MessageOneofCase.SendStreamTrailer ? (global::LiveKit.Proto.SendStreamTrailerCallback) message_ : null; } + set { + message_ = value; + messageCase_ = value == null ? MessageOneofCase.None : MessageOneofCase.SendStreamTrailer; + } + } + + /// Field number for the "byte_stream_reader_event" field. + public const int ByteStreamReaderEventFieldNumber = 28; + /// + /// Data Streams (high level) + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.ByteStreamReaderEvent ByteStreamReaderEvent { + get { return messageCase_ == MessageOneofCase.ByteStreamReaderEvent ? (global::LiveKit.Proto.ByteStreamReaderEvent) message_ : null; } + set { + message_ = value; + messageCase_ = value == null ? MessageOneofCase.None : MessageOneofCase.ByteStreamReaderEvent; + } + } + + /// Field number for the "byte_stream_reader_read_all" field. + public const int ByteStreamReaderReadAllFieldNumber = 29; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.ByteStreamReaderReadAllCallback ByteStreamReaderReadAll { + get { return messageCase_ == MessageOneofCase.ByteStreamReaderReadAll ? (global::LiveKit.Proto.ByteStreamReaderReadAllCallback) message_ : null; } + set { + message_ = value; + messageCase_ = value == null ? MessageOneofCase.None : MessageOneofCase.ByteStreamReaderReadAll; + } + } + + /// Field number for the "byte_stream_reader_write_to_file" field. + public const int ByteStreamReaderWriteToFileFieldNumber = 30; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.ByteStreamReaderWriteToFileCallback ByteStreamReaderWriteToFile { + get { return messageCase_ == MessageOneofCase.ByteStreamReaderWriteToFile ? (global::LiveKit.Proto.ByteStreamReaderWriteToFileCallback) message_ : null; } + set { + message_ = value; + messageCase_ = value == null ? MessageOneofCase.None : MessageOneofCase.ByteStreamReaderWriteToFile; + } + } + + /// Field number for the "byte_stream_open" field. + public const int ByteStreamOpenFieldNumber = 31; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.ByteStreamOpenCallback ByteStreamOpen { + get { return messageCase_ == MessageOneofCase.ByteStreamOpen ? (global::LiveKit.Proto.ByteStreamOpenCallback) message_ : null; } + set { + message_ = value; + messageCase_ = value == null ? MessageOneofCase.None : MessageOneofCase.ByteStreamOpen; + } + } + + /// Field number for the "byte_stream_writer_write" field. + public const int ByteStreamWriterWriteFieldNumber = 32; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.ByteStreamWriterWriteCallback ByteStreamWriterWrite { + get { return messageCase_ == MessageOneofCase.ByteStreamWriterWrite ? (global::LiveKit.Proto.ByteStreamWriterWriteCallback) message_ : null; } + set { + message_ = value; + messageCase_ = value == null ? MessageOneofCase.None : MessageOneofCase.ByteStreamWriterWrite; + } + } + + /// Field number for the "byte_stream_writer_close" field. + public const int ByteStreamWriterCloseFieldNumber = 33; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.ByteStreamWriterCloseCallback ByteStreamWriterClose { + get { return messageCase_ == MessageOneofCase.ByteStreamWriterClose ? (global::LiveKit.Proto.ByteStreamWriterCloseCallback) message_ : null; } + set { + message_ = value; + messageCase_ = value == null ? MessageOneofCase.None : MessageOneofCase.ByteStreamWriterClose; + } + } + + /// Field number for the "send_file" field. + public const int SendFileFieldNumber = 34; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.StreamSendFileCallback SendFile { + get { return messageCase_ == MessageOneofCase.SendFile ? (global::LiveKit.Proto.StreamSendFileCallback) message_ : null; } + set { + message_ = value; + messageCase_ = value == null ? MessageOneofCase.None : MessageOneofCase.SendFile; + } + } + + /// Field number for the "text_stream_reader_event" field. + public const int TextStreamReaderEventFieldNumber = 35; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.TextStreamReaderEvent TextStreamReaderEvent { + get { return messageCase_ == MessageOneofCase.TextStreamReaderEvent ? (global::LiveKit.Proto.TextStreamReaderEvent) message_ : null; } + set { + message_ = value; + messageCase_ = value == null ? MessageOneofCase.None : MessageOneofCase.TextStreamReaderEvent; + } + } + + /// Field number for the "text_stream_reader_read_all" field. + public const int TextStreamReaderReadAllFieldNumber = 36; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.TextStreamReaderReadAllCallback TextStreamReaderReadAll { + get { return messageCase_ == MessageOneofCase.TextStreamReaderReadAll ? (global::LiveKit.Proto.TextStreamReaderReadAllCallback) message_ : null; } + set { + message_ = value; + messageCase_ = value == null ? MessageOneofCase.None : MessageOneofCase.TextStreamReaderReadAll; + } + } + + /// Field number for the "text_stream_open" field. + public const int TextStreamOpenFieldNumber = 37; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.TextStreamOpenCallback TextStreamOpen { + get { return messageCase_ == MessageOneofCase.TextStreamOpen ? (global::LiveKit.Proto.TextStreamOpenCallback) message_ : null; } + set { + message_ = value; + messageCase_ = value == null ? MessageOneofCase.None : MessageOneofCase.TextStreamOpen; + } + } + + /// Field number for the "text_stream_writer_write" field. + public const int TextStreamWriterWriteFieldNumber = 38; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.TextStreamWriterWriteCallback TextStreamWriterWrite { + get { return messageCase_ == MessageOneofCase.TextStreamWriterWrite ? (global::LiveKit.Proto.TextStreamWriterWriteCallback) message_ : null; } + set { + message_ = value; + messageCase_ = value == null ? MessageOneofCase.None : MessageOneofCase.TextStreamWriterWrite; + } + } + + /// Field number for the "text_stream_writer_close" field. + public const int TextStreamWriterCloseFieldNumber = 39; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.TextStreamWriterCloseCallback TextStreamWriterClose { + get { return messageCase_ == MessageOneofCase.TextStreamWriterClose ? (global::LiveKit.Proto.TextStreamWriterCloseCallback) message_ : null; } + set { + message_ = value; + messageCase_ = value == null ? MessageOneofCase.None : MessageOneofCase.TextStreamWriterClose; + } + } + + /// Field number for the "send_text" field. + public const int SendTextFieldNumber = 40; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.StreamSendTextCallback SendText { + get { return messageCase_ == MessageOneofCase.SendText ? (global::LiveKit.Proto.StreamSendTextCallback) message_ : null; } + set { + message_ = value; + messageCase_ = value == null ? MessageOneofCase.None : MessageOneofCase.SendText; + } + } + private object message_; /// Enum of possible cases for the "message" oneof. public enum MessageOneofCase { @@ -5242,6 +8283,22 @@ public enum MessageOneofCase { ChatMessage = 22, PerformRpc = 23, RpcMethodInvocation = 24, + SendStreamHeader = 25, + SendStreamChunk = 26, + SendStreamTrailer = 27, + ByteStreamReaderEvent = 28, + ByteStreamReaderReadAll = 29, + ByteStreamReaderWriteToFile = 30, + ByteStreamOpen = 31, + ByteStreamWriterWrite = 32, + ByteStreamWriterClose = 33, + SendFile = 34, + TextStreamReaderEvent = 35, + TextStreamReaderReadAll = 36, + TextStreamOpen = 37, + TextStreamWriterWrite = 38, + TextStreamWriterClose = 39, + SendText = 40, } private MessageOneofCase messageCase_ = MessageOneofCase.None; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -5295,6 +8352,22 @@ public bool Equals(FfiEvent other) { if (!object.Equals(ChatMessage, other.ChatMessage)) return false; if (!object.Equals(PerformRpc, other.PerformRpc)) return false; if (!object.Equals(RpcMethodInvocation, other.RpcMethodInvocation)) return false; + if (!object.Equals(SendStreamHeader, other.SendStreamHeader)) return false; + if (!object.Equals(SendStreamChunk, other.SendStreamChunk)) return false; + if (!object.Equals(SendStreamTrailer, other.SendStreamTrailer)) return false; + if (!object.Equals(ByteStreamReaderEvent, other.ByteStreamReaderEvent)) return false; + if (!object.Equals(ByteStreamReaderReadAll, other.ByteStreamReaderReadAll)) return false; + if (!object.Equals(ByteStreamReaderWriteToFile, other.ByteStreamReaderWriteToFile)) return false; + if (!object.Equals(ByteStreamOpen, other.ByteStreamOpen)) return false; + if (!object.Equals(ByteStreamWriterWrite, other.ByteStreamWriterWrite)) return false; + if (!object.Equals(ByteStreamWriterClose, other.ByteStreamWriterClose)) return false; + if (!object.Equals(SendFile, other.SendFile)) return false; + if (!object.Equals(TextStreamReaderEvent, other.TextStreamReaderEvent)) return false; + if (!object.Equals(TextStreamReaderReadAll, other.TextStreamReaderReadAll)) return false; + if (!object.Equals(TextStreamOpen, other.TextStreamOpen)) return false; + if (!object.Equals(TextStreamWriterWrite, other.TextStreamWriterWrite)) return false; + if (!object.Equals(TextStreamWriterClose, other.TextStreamWriterClose)) return false; + if (!object.Equals(SendText, other.SendText)) return false; if (MessageCase != other.MessageCase) return false; return Equals(_unknownFields, other._unknownFields); } @@ -5326,6 +8399,22 @@ public override int GetHashCode() { if (messageCase_ == MessageOneofCase.ChatMessage) hash ^= ChatMessage.GetHashCode(); if (messageCase_ == MessageOneofCase.PerformRpc) hash ^= PerformRpc.GetHashCode(); if (messageCase_ == MessageOneofCase.RpcMethodInvocation) hash ^= RpcMethodInvocation.GetHashCode(); + if (messageCase_ == MessageOneofCase.SendStreamHeader) hash ^= SendStreamHeader.GetHashCode(); + if (messageCase_ == MessageOneofCase.SendStreamChunk) hash ^= SendStreamChunk.GetHashCode(); + if (messageCase_ == MessageOneofCase.SendStreamTrailer) hash ^= SendStreamTrailer.GetHashCode(); + if (messageCase_ == MessageOneofCase.ByteStreamReaderEvent) hash ^= ByteStreamReaderEvent.GetHashCode(); + if (messageCase_ == MessageOneofCase.ByteStreamReaderReadAll) hash ^= ByteStreamReaderReadAll.GetHashCode(); + if (messageCase_ == MessageOneofCase.ByteStreamReaderWriteToFile) hash ^= ByteStreamReaderWriteToFile.GetHashCode(); + if (messageCase_ == MessageOneofCase.ByteStreamOpen) hash ^= ByteStreamOpen.GetHashCode(); + if (messageCase_ == MessageOneofCase.ByteStreamWriterWrite) hash ^= ByteStreamWriterWrite.GetHashCode(); + if (messageCase_ == MessageOneofCase.ByteStreamWriterClose) hash ^= ByteStreamWriterClose.GetHashCode(); + if (messageCase_ == MessageOneofCase.SendFile) hash ^= SendFile.GetHashCode(); + if (messageCase_ == MessageOneofCase.TextStreamReaderEvent) hash ^= TextStreamReaderEvent.GetHashCode(); + if (messageCase_ == MessageOneofCase.TextStreamReaderReadAll) hash ^= TextStreamReaderReadAll.GetHashCode(); + if (messageCase_ == MessageOneofCase.TextStreamOpen) hash ^= TextStreamOpen.GetHashCode(); + if (messageCase_ == MessageOneofCase.TextStreamWriterWrite) hash ^= TextStreamWriterWrite.GetHashCode(); + if (messageCase_ == MessageOneofCase.TextStreamWriterClose) hash ^= TextStreamWriterClose.GetHashCode(); + if (messageCase_ == MessageOneofCase.SendText) hash ^= SendText.GetHashCode(); hash ^= (int) messageCase_; if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); @@ -5421,21 +8510,85 @@ public void WriteTo(pb::CodedOutputStream output) { output.WriteRawTag(162, 1); output.WriteMessage(Panic); } - if (messageCase_ == MessageOneofCase.PublishSipDtmf) { - output.WriteRawTag(170, 1); - output.WriteMessage(PublishSipDtmf); + if (messageCase_ == MessageOneofCase.PublishSipDtmf) { + output.WriteRawTag(170, 1); + output.WriteMessage(PublishSipDtmf); + } + if (messageCase_ == MessageOneofCase.ChatMessage) { + output.WriteRawTag(178, 1); + output.WriteMessage(ChatMessage); + } + if (messageCase_ == MessageOneofCase.PerformRpc) { + output.WriteRawTag(186, 1); + output.WriteMessage(PerformRpc); + } + if (messageCase_ == MessageOneofCase.RpcMethodInvocation) { + output.WriteRawTag(194, 1); + output.WriteMessage(RpcMethodInvocation); + } + if (messageCase_ == MessageOneofCase.SendStreamHeader) { + output.WriteRawTag(202, 1); + output.WriteMessage(SendStreamHeader); + } + if (messageCase_ == MessageOneofCase.SendStreamChunk) { + output.WriteRawTag(210, 1); + output.WriteMessage(SendStreamChunk); + } + if (messageCase_ == MessageOneofCase.SendStreamTrailer) { + output.WriteRawTag(218, 1); + output.WriteMessage(SendStreamTrailer); + } + if (messageCase_ == MessageOneofCase.ByteStreamReaderEvent) { + output.WriteRawTag(226, 1); + output.WriteMessage(ByteStreamReaderEvent); + } + if (messageCase_ == MessageOneofCase.ByteStreamReaderReadAll) { + output.WriteRawTag(234, 1); + output.WriteMessage(ByteStreamReaderReadAll); + } + if (messageCase_ == MessageOneofCase.ByteStreamReaderWriteToFile) { + output.WriteRawTag(242, 1); + output.WriteMessage(ByteStreamReaderWriteToFile); + } + if (messageCase_ == MessageOneofCase.ByteStreamOpen) { + output.WriteRawTag(250, 1); + output.WriteMessage(ByteStreamOpen); + } + if (messageCase_ == MessageOneofCase.ByteStreamWriterWrite) { + output.WriteRawTag(130, 2); + output.WriteMessage(ByteStreamWriterWrite); + } + if (messageCase_ == MessageOneofCase.ByteStreamWriterClose) { + output.WriteRawTag(138, 2); + output.WriteMessage(ByteStreamWriterClose); + } + if (messageCase_ == MessageOneofCase.SendFile) { + output.WriteRawTag(146, 2); + output.WriteMessage(SendFile); + } + if (messageCase_ == MessageOneofCase.TextStreamReaderEvent) { + output.WriteRawTag(154, 2); + output.WriteMessage(TextStreamReaderEvent); + } + if (messageCase_ == MessageOneofCase.TextStreamReaderReadAll) { + output.WriteRawTag(162, 2); + output.WriteMessage(TextStreamReaderReadAll); + } + if (messageCase_ == MessageOneofCase.TextStreamOpen) { + output.WriteRawTag(170, 2); + output.WriteMessage(TextStreamOpen); } - if (messageCase_ == MessageOneofCase.ChatMessage) { - output.WriteRawTag(178, 1); - output.WriteMessage(ChatMessage); + if (messageCase_ == MessageOneofCase.TextStreamWriterWrite) { + output.WriteRawTag(178, 2); + output.WriteMessage(TextStreamWriterWrite); } - if (messageCase_ == MessageOneofCase.PerformRpc) { - output.WriteRawTag(186, 1); - output.WriteMessage(PerformRpc); + if (messageCase_ == MessageOneofCase.TextStreamWriterClose) { + output.WriteRawTag(186, 2); + output.WriteMessage(TextStreamWriterClose); } - if (messageCase_ == MessageOneofCase.RpcMethodInvocation) { - output.WriteRawTag(194, 1); - output.WriteMessage(RpcMethodInvocation); + if (messageCase_ == MessageOneofCase.SendText) { + output.WriteRawTag(194, 2); + output.WriteMessage(SendText); } if (_unknownFields != null) { _unknownFields.WriteTo(output); @@ -5539,6 +8692,70 @@ public void WriteTo(pb::CodedOutputStream output) { output.WriteRawTag(194, 1); output.WriteMessage(RpcMethodInvocation); } + if (messageCase_ == MessageOneofCase.SendStreamHeader) { + output.WriteRawTag(202, 1); + output.WriteMessage(SendStreamHeader); + } + if (messageCase_ == MessageOneofCase.SendStreamChunk) { + output.WriteRawTag(210, 1); + output.WriteMessage(SendStreamChunk); + } + if (messageCase_ == MessageOneofCase.SendStreamTrailer) { + output.WriteRawTag(218, 1); + output.WriteMessage(SendStreamTrailer); + } + if (messageCase_ == MessageOneofCase.ByteStreamReaderEvent) { + output.WriteRawTag(226, 1); + output.WriteMessage(ByteStreamReaderEvent); + } + if (messageCase_ == MessageOneofCase.ByteStreamReaderReadAll) { + output.WriteRawTag(234, 1); + output.WriteMessage(ByteStreamReaderReadAll); + } + if (messageCase_ == MessageOneofCase.ByteStreamReaderWriteToFile) { + output.WriteRawTag(242, 1); + output.WriteMessage(ByteStreamReaderWriteToFile); + } + if (messageCase_ == MessageOneofCase.ByteStreamOpen) { + output.WriteRawTag(250, 1); + output.WriteMessage(ByteStreamOpen); + } + if (messageCase_ == MessageOneofCase.ByteStreamWriterWrite) { + output.WriteRawTag(130, 2); + output.WriteMessage(ByteStreamWriterWrite); + } + if (messageCase_ == MessageOneofCase.ByteStreamWriterClose) { + output.WriteRawTag(138, 2); + output.WriteMessage(ByteStreamWriterClose); + } + if (messageCase_ == MessageOneofCase.SendFile) { + output.WriteRawTag(146, 2); + output.WriteMessage(SendFile); + } + if (messageCase_ == MessageOneofCase.TextStreamReaderEvent) { + output.WriteRawTag(154, 2); + output.WriteMessage(TextStreamReaderEvent); + } + if (messageCase_ == MessageOneofCase.TextStreamReaderReadAll) { + output.WriteRawTag(162, 2); + output.WriteMessage(TextStreamReaderReadAll); + } + if (messageCase_ == MessageOneofCase.TextStreamOpen) { + output.WriteRawTag(170, 2); + output.WriteMessage(TextStreamOpen); + } + if (messageCase_ == MessageOneofCase.TextStreamWriterWrite) { + output.WriteRawTag(178, 2); + output.WriteMessage(TextStreamWriterWrite); + } + if (messageCase_ == MessageOneofCase.TextStreamWriterClose) { + output.WriteRawTag(186, 2); + output.WriteMessage(TextStreamWriterClose); + } + if (messageCase_ == MessageOneofCase.SendText) { + output.WriteRawTag(194, 2); + output.WriteMessage(SendText); + } if (_unknownFields != null) { _unknownFields.WriteTo(ref output); } @@ -5618,6 +8835,54 @@ public int CalculateSize() { if (messageCase_ == MessageOneofCase.RpcMethodInvocation) { size += 2 + pb::CodedOutputStream.ComputeMessageSize(RpcMethodInvocation); } + if (messageCase_ == MessageOneofCase.SendStreamHeader) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(SendStreamHeader); + } + if (messageCase_ == MessageOneofCase.SendStreamChunk) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(SendStreamChunk); + } + if (messageCase_ == MessageOneofCase.SendStreamTrailer) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(SendStreamTrailer); + } + if (messageCase_ == MessageOneofCase.ByteStreamReaderEvent) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(ByteStreamReaderEvent); + } + if (messageCase_ == MessageOneofCase.ByteStreamReaderReadAll) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(ByteStreamReaderReadAll); + } + if (messageCase_ == MessageOneofCase.ByteStreamReaderWriteToFile) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(ByteStreamReaderWriteToFile); + } + if (messageCase_ == MessageOneofCase.ByteStreamOpen) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(ByteStreamOpen); + } + if (messageCase_ == MessageOneofCase.ByteStreamWriterWrite) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(ByteStreamWriterWrite); + } + if (messageCase_ == MessageOneofCase.ByteStreamWriterClose) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(ByteStreamWriterClose); + } + if (messageCase_ == MessageOneofCase.SendFile) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(SendFile); + } + if (messageCase_ == MessageOneofCase.TextStreamReaderEvent) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(TextStreamReaderEvent); + } + if (messageCase_ == MessageOneofCase.TextStreamReaderReadAll) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(TextStreamReaderReadAll); + } + if (messageCase_ == MessageOneofCase.TextStreamOpen) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(TextStreamOpen); + } + if (messageCase_ == MessageOneofCase.TextStreamWriterWrite) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(TextStreamWriterWrite); + } + if (messageCase_ == MessageOneofCase.TextStreamWriterClose) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(TextStreamWriterClose); + } + if (messageCase_ == MessageOneofCase.SendText) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(SendText); + } if (_unknownFields != null) { size += _unknownFields.CalculateSize(); } @@ -5769,6 +9034,102 @@ public void MergeFrom(FfiEvent other) { } RpcMethodInvocation.MergeFrom(other.RpcMethodInvocation); break; + case MessageOneofCase.SendStreamHeader: + if (SendStreamHeader == null) { + SendStreamHeader = new global::LiveKit.Proto.SendStreamHeaderCallback(); + } + SendStreamHeader.MergeFrom(other.SendStreamHeader); + break; + case MessageOneofCase.SendStreamChunk: + if (SendStreamChunk == null) { + SendStreamChunk = new global::LiveKit.Proto.SendStreamChunkCallback(); + } + SendStreamChunk.MergeFrom(other.SendStreamChunk); + break; + case MessageOneofCase.SendStreamTrailer: + if (SendStreamTrailer == null) { + SendStreamTrailer = new global::LiveKit.Proto.SendStreamTrailerCallback(); + } + SendStreamTrailer.MergeFrom(other.SendStreamTrailer); + break; + case MessageOneofCase.ByteStreamReaderEvent: + if (ByteStreamReaderEvent == null) { + ByteStreamReaderEvent = new global::LiveKit.Proto.ByteStreamReaderEvent(); + } + ByteStreamReaderEvent.MergeFrom(other.ByteStreamReaderEvent); + break; + case MessageOneofCase.ByteStreamReaderReadAll: + if (ByteStreamReaderReadAll == null) { + ByteStreamReaderReadAll = new global::LiveKit.Proto.ByteStreamReaderReadAllCallback(); + } + ByteStreamReaderReadAll.MergeFrom(other.ByteStreamReaderReadAll); + break; + case MessageOneofCase.ByteStreamReaderWriteToFile: + if (ByteStreamReaderWriteToFile == null) { + ByteStreamReaderWriteToFile = new global::LiveKit.Proto.ByteStreamReaderWriteToFileCallback(); + } + ByteStreamReaderWriteToFile.MergeFrom(other.ByteStreamReaderWriteToFile); + break; + case MessageOneofCase.ByteStreamOpen: + if (ByteStreamOpen == null) { + ByteStreamOpen = new global::LiveKit.Proto.ByteStreamOpenCallback(); + } + ByteStreamOpen.MergeFrom(other.ByteStreamOpen); + break; + case MessageOneofCase.ByteStreamWriterWrite: + if (ByteStreamWriterWrite == null) { + ByteStreamWriterWrite = new global::LiveKit.Proto.ByteStreamWriterWriteCallback(); + } + ByteStreamWriterWrite.MergeFrom(other.ByteStreamWriterWrite); + break; + case MessageOneofCase.ByteStreamWriterClose: + if (ByteStreamWriterClose == null) { + ByteStreamWriterClose = new global::LiveKit.Proto.ByteStreamWriterCloseCallback(); + } + ByteStreamWriterClose.MergeFrom(other.ByteStreamWriterClose); + break; + case MessageOneofCase.SendFile: + if (SendFile == null) { + SendFile = new global::LiveKit.Proto.StreamSendFileCallback(); + } + SendFile.MergeFrom(other.SendFile); + break; + case MessageOneofCase.TextStreamReaderEvent: + if (TextStreamReaderEvent == null) { + TextStreamReaderEvent = new global::LiveKit.Proto.TextStreamReaderEvent(); + } + TextStreamReaderEvent.MergeFrom(other.TextStreamReaderEvent); + break; + case MessageOneofCase.TextStreamReaderReadAll: + if (TextStreamReaderReadAll == null) { + TextStreamReaderReadAll = new global::LiveKit.Proto.TextStreamReaderReadAllCallback(); + } + TextStreamReaderReadAll.MergeFrom(other.TextStreamReaderReadAll); + break; + case MessageOneofCase.TextStreamOpen: + if (TextStreamOpen == null) { + TextStreamOpen = new global::LiveKit.Proto.TextStreamOpenCallback(); + } + TextStreamOpen.MergeFrom(other.TextStreamOpen); + break; + case MessageOneofCase.TextStreamWriterWrite: + if (TextStreamWriterWrite == null) { + TextStreamWriterWrite = new global::LiveKit.Proto.TextStreamWriterWriteCallback(); + } + TextStreamWriterWrite.MergeFrom(other.TextStreamWriterWrite); + break; + case MessageOneofCase.TextStreamWriterClose: + if (TextStreamWriterClose == null) { + TextStreamWriterClose = new global::LiveKit.Proto.TextStreamWriterCloseCallback(); + } + TextStreamWriterClose.MergeFrom(other.TextStreamWriterClose); + break; + case MessageOneofCase.SendText: + if (SendText == null) { + SendText = new global::LiveKit.Proto.StreamSendTextCallback(); + } + SendText.MergeFrom(other.SendText); + break; } _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); @@ -5997,6 +9358,150 @@ public void MergeFrom(pb::CodedInputStream input) { RpcMethodInvocation = subBuilder; break; } + case 202: { + global::LiveKit.Proto.SendStreamHeaderCallback subBuilder = new global::LiveKit.Proto.SendStreamHeaderCallback(); + if (messageCase_ == MessageOneofCase.SendStreamHeader) { + subBuilder.MergeFrom(SendStreamHeader); + } + input.ReadMessage(subBuilder); + SendStreamHeader = subBuilder; + break; + } + case 210: { + global::LiveKit.Proto.SendStreamChunkCallback subBuilder = new global::LiveKit.Proto.SendStreamChunkCallback(); + if (messageCase_ == MessageOneofCase.SendStreamChunk) { + subBuilder.MergeFrom(SendStreamChunk); + } + input.ReadMessage(subBuilder); + SendStreamChunk = subBuilder; + break; + } + case 218: { + global::LiveKit.Proto.SendStreamTrailerCallback subBuilder = new global::LiveKit.Proto.SendStreamTrailerCallback(); + if (messageCase_ == MessageOneofCase.SendStreamTrailer) { + subBuilder.MergeFrom(SendStreamTrailer); + } + input.ReadMessage(subBuilder); + SendStreamTrailer = subBuilder; + break; + } + case 226: { + global::LiveKit.Proto.ByteStreamReaderEvent subBuilder = new global::LiveKit.Proto.ByteStreamReaderEvent(); + if (messageCase_ == MessageOneofCase.ByteStreamReaderEvent) { + subBuilder.MergeFrom(ByteStreamReaderEvent); + } + input.ReadMessage(subBuilder); + ByteStreamReaderEvent = subBuilder; + break; + } + case 234: { + global::LiveKit.Proto.ByteStreamReaderReadAllCallback subBuilder = new global::LiveKit.Proto.ByteStreamReaderReadAllCallback(); + if (messageCase_ == MessageOneofCase.ByteStreamReaderReadAll) { + subBuilder.MergeFrom(ByteStreamReaderReadAll); + } + input.ReadMessage(subBuilder); + ByteStreamReaderReadAll = subBuilder; + break; + } + case 242: { + global::LiveKit.Proto.ByteStreamReaderWriteToFileCallback subBuilder = new global::LiveKit.Proto.ByteStreamReaderWriteToFileCallback(); + if (messageCase_ == MessageOneofCase.ByteStreamReaderWriteToFile) { + subBuilder.MergeFrom(ByteStreamReaderWriteToFile); + } + input.ReadMessage(subBuilder); + ByteStreamReaderWriteToFile = subBuilder; + break; + } + case 250: { + global::LiveKit.Proto.ByteStreamOpenCallback subBuilder = new global::LiveKit.Proto.ByteStreamOpenCallback(); + if (messageCase_ == MessageOneofCase.ByteStreamOpen) { + subBuilder.MergeFrom(ByteStreamOpen); + } + input.ReadMessage(subBuilder); + ByteStreamOpen = subBuilder; + break; + } + case 258: { + global::LiveKit.Proto.ByteStreamWriterWriteCallback subBuilder = new global::LiveKit.Proto.ByteStreamWriterWriteCallback(); + if (messageCase_ == MessageOneofCase.ByteStreamWriterWrite) { + subBuilder.MergeFrom(ByteStreamWriterWrite); + } + input.ReadMessage(subBuilder); + ByteStreamWriterWrite = subBuilder; + break; + } + case 266: { + global::LiveKit.Proto.ByteStreamWriterCloseCallback subBuilder = new global::LiveKit.Proto.ByteStreamWriterCloseCallback(); + if (messageCase_ == MessageOneofCase.ByteStreamWriterClose) { + subBuilder.MergeFrom(ByteStreamWriterClose); + } + input.ReadMessage(subBuilder); + ByteStreamWriterClose = subBuilder; + break; + } + case 274: { + global::LiveKit.Proto.StreamSendFileCallback subBuilder = new global::LiveKit.Proto.StreamSendFileCallback(); + if (messageCase_ == MessageOneofCase.SendFile) { + subBuilder.MergeFrom(SendFile); + } + input.ReadMessage(subBuilder); + SendFile = subBuilder; + break; + } + case 282: { + global::LiveKit.Proto.TextStreamReaderEvent subBuilder = new global::LiveKit.Proto.TextStreamReaderEvent(); + if (messageCase_ == MessageOneofCase.TextStreamReaderEvent) { + subBuilder.MergeFrom(TextStreamReaderEvent); + } + input.ReadMessage(subBuilder); + TextStreamReaderEvent = subBuilder; + break; + } + case 290: { + global::LiveKit.Proto.TextStreamReaderReadAllCallback subBuilder = new global::LiveKit.Proto.TextStreamReaderReadAllCallback(); + if (messageCase_ == MessageOneofCase.TextStreamReaderReadAll) { + subBuilder.MergeFrom(TextStreamReaderReadAll); + } + input.ReadMessage(subBuilder); + TextStreamReaderReadAll = subBuilder; + break; + } + case 298: { + global::LiveKit.Proto.TextStreamOpenCallback subBuilder = new global::LiveKit.Proto.TextStreamOpenCallback(); + if (messageCase_ == MessageOneofCase.TextStreamOpen) { + subBuilder.MergeFrom(TextStreamOpen); + } + input.ReadMessage(subBuilder); + TextStreamOpen = subBuilder; + break; + } + case 306: { + global::LiveKit.Proto.TextStreamWriterWriteCallback subBuilder = new global::LiveKit.Proto.TextStreamWriterWriteCallback(); + if (messageCase_ == MessageOneofCase.TextStreamWriterWrite) { + subBuilder.MergeFrom(TextStreamWriterWrite); + } + input.ReadMessage(subBuilder); + TextStreamWriterWrite = subBuilder; + break; + } + case 314: { + global::LiveKit.Proto.TextStreamWriterCloseCallback subBuilder = new global::LiveKit.Proto.TextStreamWriterCloseCallback(); + if (messageCase_ == MessageOneofCase.TextStreamWriterClose) { + subBuilder.MergeFrom(TextStreamWriterClose); + } + input.ReadMessage(subBuilder); + TextStreamWriterClose = subBuilder; + break; + } + case 322: { + global::LiveKit.Proto.StreamSendTextCallback subBuilder = new global::LiveKit.Proto.StreamSendTextCallback(); + if (messageCase_ == MessageOneofCase.SendText) { + subBuilder.MergeFrom(SendText); + } + input.ReadMessage(subBuilder); + SendText = subBuilder; + break; + } } } #endif @@ -6223,6 +9728,150 @@ public void MergeFrom(pb::CodedInputStream input) { RpcMethodInvocation = subBuilder; break; } + case 202: { + global::LiveKit.Proto.SendStreamHeaderCallback subBuilder = new global::LiveKit.Proto.SendStreamHeaderCallback(); + if (messageCase_ == MessageOneofCase.SendStreamHeader) { + subBuilder.MergeFrom(SendStreamHeader); + } + input.ReadMessage(subBuilder); + SendStreamHeader = subBuilder; + break; + } + case 210: { + global::LiveKit.Proto.SendStreamChunkCallback subBuilder = new global::LiveKit.Proto.SendStreamChunkCallback(); + if (messageCase_ == MessageOneofCase.SendStreamChunk) { + subBuilder.MergeFrom(SendStreamChunk); + } + input.ReadMessage(subBuilder); + SendStreamChunk = subBuilder; + break; + } + case 218: { + global::LiveKit.Proto.SendStreamTrailerCallback subBuilder = new global::LiveKit.Proto.SendStreamTrailerCallback(); + if (messageCase_ == MessageOneofCase.SendStreamTrailer) { + subBuilder.MergeFrom(SendStreamTrailer); + } + input.ReadMessage(subBuilder); + SendStreamTrailer = subBuilder; + break; + } + case 226: { + global::LiveKit.Proto.ByteStreamReaderEvent subBuilder = new global::LiveKit.Proto.ByteStreamReaderEvent(); + if (messageCase_ == MessageOneofCase.ByteStreamReaderEvent) { + subBuilder.MergeFrom(ByteStreamReaderEvent); + } + input.ReadMessage(subBuilder); + ByteStreamReaderEvent = subBuilder; + break; + } + case 234: { + global::LiveKit.Proto.ByteStreamReaderReadAllCallback subBuilder = new global::LiveKit.Proto.ByteStreamReaderReadAllCallback(); + if (messageCase_ == MessageOneofCase.ByteStreamReaderReadAll) { + subBuilder.MergeFrom(ByteStreamReaderReadAll); + } + input.ReadMessage(subBuilder); + ByteStreamReaderReadAll = subBuilder; + break; + } + case 242: { + global::LiveKit.Proto.ByteStreamReaderWriteToFileCallback subBuilder = new global::LiveKit.Proto.ByteStreamReaderWriteToFileCallback(); + if (messageCase_ == MessageOneofCase.ByteStreamReaderWriteToFile) { + subBuilder.MergeFrom(ByteStreamReaderWriteToFile); + } + input.ReadMessage(subBuilder); + ByteStreamReaderWriteToFile = subBuilder; + break; + } + case 250: { + global::LiveKit.Proto.ByteStreamOpenCallback subBuilder = new global::LiveKit.Proto.ByteStreamOpenCallback(); + if (messageCase_ == MessageOneofCase.ByteStreamOpen) { + subBuilder.MergeFrom(ByteStreamOpen); + } + input.ReadMessage(subBuilder); + ByteStreamOpen = subBuilder; + break; + } + case 258: { + global::LiveKit.Proto.ByteStreamWriterWriteCallback subBuilder = new global::LiveKit.Proto.ByteStreamWriterWriteCallback(); + if (messageCase_ == MessageOneofCase.ByteStreamWriterWrite) { + subBuilder.MergeFrom(ByteStreamWriterWrite); + } + input.ReadMessage(subBuilder); + ByteStreamWriterWrite = subBuilder; + break; + } + case 266: { + global::LiveKit.Proto.ByteStreamWriterCloseCallback subBuilder = new global::LiveKit.Proto.ByteStreamWriterCloseCallback(); + if (messageCase_ == MessageOneofCase.ByteStreamWriterClose) { + subBuilder.MergeFrom(ByteStreamWriterClose); + } + input.ReadMessage(subBuilder); + ByteStreamWriterClose = subBuilder; + break; + } + case 274: { + global::LiveKit.Proto.StreamSendFileCallback subBuilder = new global::LiveKit.Proto.StreamSendFileCallback(); + if (messageCase_ == MessageOneofCase.SendFile) { + subBuilder.MergeFrom(SendFile); + } + input.ReadMessage(subBuilder); + SendFile = subBuilder; + break; + } + case 282: { + global::LiveKit.Proto.TextStreamReaderEvent subBuilder = new global::LiveKit.Proto.TextStreamReaderEvent(); + if (messageCase_ == MessageOneofCase.TextStreamReaderEvent) { + subBuilder.MergeFrom(TextStreamReaderEvent); + } + input.ReadMessage(subBuilder); + TextStreamReaderEvent = subBuilder; + break; + } + case 290: { + global::LiveKit.Proto.TextStreamReaderReadAllCallback subBuilder = new global::LiveKit.Proto.TextStreamReaderReadAllCallback(); + if (messageCase_ == MessageOneofCase.TextStreamReaderReadAll) { + subBuilder.MergeFrom(TextStreamReaderReadAll); + } + input.ReadMessage(subBuilder); + TextStreamReaderReadAll = subBuilder; + break; + } + case 298: { + global::LiveKit.Proto.TextStreamOpenCallback subBuilder = new global::LiveKit.Proto.TextStreamOpenCallback(); + if (messageCase_ == MessageOneofCase.TextStreamOpen) { + subBuilder.MergeFrom(TextStreamOpen); + } + input.ReadMessage(subBuilder); + TextStreamOpen = subBuilder; + break; + } + case 306: { + global::LiveKit.Proto.TextStreamWriterWriteCallback subBuilder = new global::LiveKit.Proto.TextStreamWriterWriteCallback(); + if (messageCase_ == MessageOneofCase.TextStreamWriterWrite) { + subBuilder.MergeFrom(TextStreamWriterWrite); + } + input.ReadMessage(subBuilder); + TextStreamWriterWrite = subBuilder; + break; + } + case 314: { + global::LiveKit.Proto.TextStreamWriterCloseCallback subBuilder = new global::LiveKit.Proto.TextStreamWriterCloseCallback(); + if (messageCase_ == MessageOneofCase.TextStreamWriterClose) { + subBuilder.MergeFrom(TextStreamWriterClose); + } + input.ReadMessage(subBuilder); + TextStreamWriterClose = subBuilder; + break; + } + case 322: { + global::LiveKit.Proto.StreamSendTextCallback subBuilder = new global::LiveKit.Proto.StreamSendTextCallback(); + if (messageCase_ == MessageOneofCase.SendText) { + subBuilder.MergeFrom(SendText); + } + input.ReadMessage(subBuilder); + SendText = subBuilder; + break; + } } } } diff --git a/Runtime/Scripts/Proto/Participant.cs b/Runtime/Scripts/Proto/Participant.cs index 92fbf5f7..9b6fa8f1 100644 --- a/Runtime/Scripts/Proto/Participant.cs +++ b/Runtime/Scripts/Proto/Participant.cs @@ -25,23 +25,31 @@ static ParticipantReflection() { byte[] descriptorData = global::System.Convert.FromBase64String( string.Concat( "ChFwYXJ0aWNpcGFudC5wcm90bxINbGl2ZWtpdC5wcm90bxoMaGFuZGxlLnBy", - "b3RvIvUBCg9QYXJ0aWNpcGFudEluZm8SCwoDc2lkGAEgAigJEgwKBG5hbWUY", + "b3RvIrECCg9QYXJ0aWNpcGFudEluZm8SCwoDc2lkGAEgAigJEgwKBG5hbWUY", "AiACKAkSEAoIaWRlbnRpdHkYAyACKAkSEAoIbWV0YWRhdGEYBCACKAkSQgoK", "YXR0cmlidXRlcxgFIAMoCzIuLmxpdmVraXQucHJvdG8uUGFydGljaXBhbnRJ", "bmZvLkF0dHJpYnV0ZXNFbnRyeRIsCgRraW5kGAYgAigOMh4ubGl2ZWtpdC5w", - "cm90by5QYXJ0aWNpcGFudEtpbmQaMQoPQXR0cmlidXRlc0VudHJ5EgsKA2tl", - "eRgBIAEoCRINCgV2YWx1ZRgCIAEoCToCOAEibwoQT3duZWRQYXJ0aWNpcGFu", - "dBItCgZoYW5kbGUYASACKAsyHS5saXZla2l0LnByb3RvLkZmaU93bmVkSGFu", - "ZGxlEiwKBGluZm8YAiACKAsyHi5saXZla2l0LnByb3RvLlBhcnRpY2lwYW50", - "SW5mbyqhAQoPUGFydGljaXBhbnRLaW5kEh0KGVBBUlRJQ0lQQU5UX0tJTkRf", - "U1RBTkRBUkQQABIcChhQQVJUSUNJUEFOVF9LSU5EX0lOR1JFU1MQARIbChdQ", - "QVJUSUNJUEFOVF9LSU5EX0VHUkVTUxACEhgKFFBBUlRJQ0lQQU5UX0tJTkRf", - "U0lQEAMSGgoWUEFSVElDSVBBTlRfS0lORF9BR0VOVBAEQhCqAg1MaXZlS2l0", - "LlByb3Rv")); + "cm90by5QYXJ0aWNpcGFudEtpbmQSOgoRZGlzY29ubmVjdF9yZWFzb24YByAC", + "KA4yHy5saXZla2l0LnByb3RvLkRpc2Nvbm5lY3RSZWFzb24aMQoPQXR0cmli", + "dXRlc0VudHJ5EgsKA2tleRgBIAEoCRINCgV2YWx1ZRgCIAEoCToCOAEibwoQ", + "T3duZWRQYXJ0aWNpcGFudBItCgZoYW5kbGUYASACKAsyHS5saXZla2l0LnBy", + "b3RvLkZmaU93bmVkSGFuZGxlEiwKBGluZm8YAiACKAsyHi5saXZla2l0LnBy", + "b3RvLlBhcnRpY2lwYW50SW5mbyqhAQoPUGFydGljaXBhbnRLaW5kEh0KGVBB", + "UlRJQ0lQQU5UX0tJTkRfU1RBTkRBUkQQABIcChhQQVJUSUNJUEFOVF9LSU5E", + "X0lOR1JFU1MQARIbChdQQVJUSUNJUEFOVF9LSU5EX0VHUkVTUxACEhgKFFBB", + "UlRJQ0lQQU5UX0tJTkRfU0lQEAMSGgoWUEFSVElDSVBBTlRfS0lORF9BR0VO", + "VBAEKqwCChBEaXNjb25uZWN0UmVhc29uEhIKDlVOS05PV05fUkVBU09OEAAS", + "FAoQQ0xJRU5UX0lOSVRJQVRFRBABEhYKEkRVUExJQ0FURV9JREVOVElUWRAC", + "EhMKD1NFUlZFUl9TSFVURE9XThADEhcKE1BBUlRJQ0lQQU5UX1JFTU9WRUQQ", + "BBIQCgxST09NX0RFTEVURUQQBRISCg5TVEFURV9NSVNNQVRDSBAGEhAKDEpP", + "SU5fRkFJTFVSRRAHEg0KCU1JR1JBVElPThAIEhAKDFNJR05BTF9DTE9TRRAJ", + "Eg8KC1JPT01fQ0xPU0VEEAoSFAoQVVNFUl9VTkFWQUlMQUJMRRALEhEKDVVT", + "RVJfUkVKRUNURUQQDBIVChFTSVBfVFJVTktfRkFJTFVSRRANQhCqAg1MaXZl", + "S2l0LlByb3Rv")); descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData, new pbr::FileDescriptor[] { global::LiveKit.Proto.HandleReflection.Descriptor, }, - new pbr::GeneratedClrTypeInfo(new[] {typeof(global::LiveKit.Proto.ParticipantKind), }, null, new pbr::GeneratedClrTypeInfo[] { - new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.ParticipantInfo), global::LiveKit.Proto.ParticipantInfo.Parser, new[]{ "Sid", "Name", "Identity", "Metadata", "Attributes", "Kind" }, null, null, null, new pbr::GeneratedClrTypeInfo[] { null, }), + new pbr::GeneratedClrTypeInfo(new[] {typeof(global::LiveKit.Proto.ParticipantKind), typeof(global::LiveKit.Proto.DisconnectReason), }, null, new pbr::GeneratedClrTypeInfo[] { + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.ParticipantInfo), global::LiveKit.Proto.ParticipantInfo.Parser, new[]{ "Sid", "Name", "Identity", "Metadata", "Attributes", "Kind", "DisconnectReason" }, null, null, null, new pbr::GeneratedClrTypeInfo[] { null, }), new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.OwnedParticipant), global::LiveKit.Proto.OwnedParticipant.Parser, new[]{ "Handle", "Info" }, null, null, null, null) })); } @@ -57,6 +65,62 @@ public enum ParticipantKind { [pbr::OriginalName("PARTICIPANT_KIND_AGENT")] Agent = 4, } + public enum DisconnectReason { + [pbr::OriginalName("UNKNOWN_REASON")] UnknownReason = 0, + /// + /// the client initiated the disconnect + /// + [pbr::OriginalName("CLIENT_INITIATED")] ClientInitiated = 1, + /// + /// another participant with the same identity has joined the room + /// + [pbr::OriginalName("DUPLICATE_IDENTITY")] DuplicateIdentity = 2, + /// + /// the server instance is shutting down + /// + [pbr::OriginalName("SERVER_SHUTDOWN")] ServerShutdown = 3, + /// + /// RoomService.RemoveParticipant was called + /// + [pbr::OriginalName("PARTICIPANT_REMOVED")] ParticipantRemoved = 4, + /// + /// RoomService.DeleteRoom was called + /// + [pbr::OriginalName("ROOM_DELETED")] RoomDeleted = 5, + /// + /// the client is attempting to resume a session, but server is not aware of it + /// + [pbr::OriginalName("STATE_MISMATCH")] StateMismatch = 6, + /// + /// client was unable to connect fully + /// + [pbr::OriginalName("JOIN_FAILURE")] JoinFailure = 7, + /// + /// Cloud-only, the server requested Participant to migrate the connection elsewhere + /// + [pbr::OriginalName("MIGRATION")] Migration = 8, + /// + /// the signal websocket was closed unexpectedly + /// + [pbr::OriginalName("SIGNAL_CLOSE")] SignalClose = 9, + /// + /// the room was closed, due to all Standard and Ingress participants having left + /// + [pbr::OriginalName("ROOM_CLOSED")] RoomClosed = 10, + /// + /// SIP callee did not respond in time + /// + [pbr::OriginalName("USER_UNAVAILABLE")] UserUnavailable = 11, + /// + /// SIP callee rejected the call (busy) + /// + [pbr::OriginalName("USER_REJECTED")] UserRejected = 12, + /// + /// SIP protocol failure or unexpected response + /// + [pbr::OriginalName("SIP_TRUNK_FAILURE")] SipTrunkFailure = 13, + } + #endregion #region Messages @@ -103,6 +167,7 @@ public ParticipantInfo(ParticipantInfo other) : this() { metadata_ = other.metadata_; attributes_ = other.attributes_.Clone(); kind_ = other.kind_; + disconnectReason_ = other.disconnectReason_; _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); } @@ -254,6 +319,33 @@ public void ClearKind() { _hasBits0 &= ~1; } + /// Field number for the "disconnect_reason" field. + public const int DisconnectReasonFieldNumber = 7; + private readonly static global::LiveKit.Proto.DisconnectReason DisconnectReasonDefaultValue = global::LiveKit.Proto.DisconnectReason.UnknownReason; + + private global::LiveKit.Proto.DisconnectReason disconnectReason_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.DisconnectReason DisconnectReason { + get { if ((_hasBits0 & 2) != 0) { return disconnectReason_; } else { return DisconnectReasonDefaultValue; } } + set { + _hasBits0 |= 2; + disconnectReason_ = value; + } + } + /// Gets whether the "disconnect_reason" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasDisconnectReason { + get { return (_hasBits0 & 2) != 0; } + } + /// Clears the value of the "disconnect_reason" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearDisconnectReason() { + _hasBits0 &= ~2; + } + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override bool Equals(object other) { @@ -275,6 +367,7 @@ public bool Equals(ParticipantInfo other) { if (Metadata != other.Metadata) return false; if (!Attributes.Equals(other.Attributes)) return false; if (Kind != other.Kind) return false; + if (DisconnectReason != other.DisconnectReason) return false; return Equals(_unknownFields, other._unknownFields); } @@ -288,6 +381,7 @@ public override int GetHashCode() { if (HasMetadata) hash ^= Metadata.GetHashCode(); hash ^= Attributes.GetHashCode(); if (HasKind) hash ^= Kind.GetHashCode(); + if (HasDisconnectReason) hash ^= DisconnectReason.GetHashCode(); if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } @@ -327,6 +421,10 @@ public void WriteTo(pb::CodedOutputStream output) { output.WriteRawTag(48); output.WriteEnum((int) Kind); } + if (HasDisconnectReason) { + output.WriteRawTag(56); + output.WriteEnum((int) DisconnectReason); + } if (_unknownFields != null) { _unknownFields.WriteTo(output); } @@ -358,6 +456,10 @@ public void WriteTo(pb::CodedOutputStream output) { output.WriteRawTag(48); output.WriteEnum((int) Kind); } + if (HasDisconnectReason) { + output.WriteRawTag(56); + output.WriteEnum((int) DisconnectReason); + } if (_unknownFields != null) { _unknownFields.WriteTo(ref output); } @@ -384,6 +486,9 @@ public int CalculateSize() { if (HasKind) { size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) Kind); } + if (HasDisconnectReason) { + size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) DisconnectReason); + } if (_unknownFields != null) { size += _unknownFields.CalculateSize(); } @@ -412,6 +517,9 @@ public void MergeFrom(ParticipantInfo other) { if (other.HasKind) { Kind = other.Kind; } + if (other.HasDisconnectReason) { + DisconnectReason = other.DisconnectReason; + } _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); } @@ -455,6 +563,10 @@ public void MergeFrom(pb::CodedInputStream input) { Kind = (global::LiveKit.Proto.ParticipantKind) input.ReadEnum(); break; } + case 56: { + DisconnectReason = (global::LiveKit.Proto.DisconnectReason) input.ReadEnum(); + break; + } } } #endif @@ -498,6 +610,10 @@ public void MergeFrom(pb::CodedInputStream input) { Kind = (global::LiveKit.Proto.ParticipantKind) input.ReadEnum(); break; } + case 56: { + DisconnectReason = (global::LiveKit.Proto.DisconnectReason) input.ReadEnum(); + break; + } } } } diff --git a/Runtime/Scripts/Proto/Room.cs b/Runtime/Scripts/Proto/Room.cs index a2d00595..bfad5c69 100644 --- a/Runtime/Scripts/Proto/Room.cs +++ b/Runtime/Scripts/Proto/Room.cs @@ -26,226 +26,292 @@ static RoomReflection() { string.Concat( "Cgpyb29tLnByb3RvEg1saXZla2l0LnByb3RvGgplMmVlLnByb3RvGgxoYW5k", "bGUucHJvdG8aEXBhcnRpY2lwYW50LnByb3RvGgt0cmFjay5wcm90bxoRdmlk", - "ZW9fZnJhbWUucHJvdG8aC3N0YXRzLnByb3RvIlkKDkNvbm5lY3RSZXF1ZXN0", - "EgsKA3VybBgBIAIoCRINCgV0b2tlbhgCIAIoCRIrCgdvcHRpb25zGAMgAigL", - "MhoubGl2ZWtpdC5wcm90by5Sb29tT3B0aW9ucyIjCg9Db25uZWN0UmVzcG9u", - "c2USEAoIYXN5bmNfaWQYASACKAQivwMKD0Nvbm5lY3RDYWxsYmFjaxIQCghh", - "c3luY19pZBgBIAIoBBIPCgVlcnJvchgCIAEoCUgAEjcKBnJlc3VsdBgDIAEo", - "CzIlLmxpdmVraXQucHJvdG8uQ29ubmVjdENhbGxiYWNrLlJlc3VsdEgAGokB", - "ChVQYXJ0aWNpcGFudFdpdGhUcmFja3MSNAoLcGFydGljaXBhbnQYASACKAsy", - "Hy5saXZla2l0LnByb3RvLk93bmVkUGFydGljaXBhbnQSOgoMcHVibGljYXRp", - "b25zGAIgAygLMiQubGl2ZWtpdC5wcm90by5Pd25lZFRyYWNrUHVibGljYXRp", - "b24auAEKBlJlc3VsdBImCgRyb29tGAEgAigLMhgubGl2ZWtpdC5wcm90by5P", - "d25lZFJvb20SOgoRbG9jYWxfcGFydGljaXBhbnQYAiACKAsyHy5saXZla2l0", - "LnByb3RvLk93bmVkUGFydGljaXBhbnQSSgoMcGFydGljaXBhbnRzGAMgAygL", - "MjQubGl2ZWtpdC5wcm90by5Db25uZWN0Q2FsbGJhY2suUGFydGljaXBhbnRX", - "aXRoVHJhY2tzQgkKB21lc3NhZ2UiKAoRRGlzY29ubmVjdFJlcXVlc3QSEwoL", - "cm9vbV9oYW5kbGUYASACKAQiJgoSRGlzY29ubmVjdFJlc3BvbnNlEhAKCGFz", - "eW5jX2lkGAEgAigEIiYKEkRpc2Nvbm5lY3RDYWxsYmFjaxIQCghhc3luY19p", - "ZBgBIAIoBCKCAQoTUHVibGlzaFRyYWNrUmVxdWVzdBIgChhsb2NhbF9wYXJ0", - "aWNpcGFudF9oYW5kbGUYASACKAQSFAoMdHJhY2tfaGFuZGxlGAIgAigEEjMK", - "B29wdGlvbnMYAyACKAsyIi5saXZla2l0LnByb3RvLlRyYWNrUHVibGlzaE9w", - "dGlvbnMiKAoUUHVibGlzaFRyYWNrUmVzcG9uc2USEAoIYXN5bmNfaWQYASAC", - "KAQigQEKFFB1Ymxpc2hUcmFja0NhbGxiYWNrEhAKCGFzeW5jX2lkGAEgAigE", - "Eg8KBWVycm9yGAIgASgJSAASOwoLcHVibGljYXRpb24YAyABKAsyJC5saXZl", - "a2l0LnByb3RvLk93bmVkVHJhY2tQdWJsaWNhdGlvbkgAQgkKB21lc3NhZ2Ui", - "ZwoVVW5wdWJsaXNoVHJhY2tSZXF1ZXN0EiAKGGxvY2FsX3BhcnRpY2lwYW50", - "X2hhbmRsZRgBIAIoBBIRCgl0cmFja19zaWQYAiACKAkSGQoRc3RvcF9vbl91", - "bnB1Ymxpc2gYAyACKAgiKgoWVW5wdWJsaXNoVHJhY2tSZXNwb25zZRIQCghh", - "c3luY19pZBgBIAIoBCI5ChZVbnB1Ymxpc2hUcmFja0NhbGxiYWNrEhAKCGFz", - "eW5jX2lkGAEgAigEEg0KBWVycm9yGAIgASgJIrkBChJQdWJsaXNoRGF0YVJl", - "cXVlc3QSIAoYbG9jYWxfcGFydGljaXBhbnRfaGFuZGxlGAEgAigEEhAKCGRh", - "dGFfcHRyGAIgAigEEhAKCGRhdGFfbGVuGAMgAigEEhAKCHJlbGlhYmxlGAQg", - "AigIEhwKEGRlc3RpbmF0aW9uX3NpZHMYBSADKAlCAhgBEg0KBXRvcGljGAYg", - "ASgJEh4KFmRlc3RpbmF0aW9uX2lkZW50aXRpZXMYByADKAkiJwoTUHVibGlz", - "aERhdGFSZXNwb25zZRIQCghhc3luY19pZBgBIAIoBCI2ChNQdWJsaXNoRGF0", - "YUNhbGxiYWNrEhAKCGFzeW5jX2lkGAEgAigEEg0KBWVycm9yGAIgASgJIqYB", - "ChtQdWJsaXNoVHJhbnNjcmlwdGlvblJlcXVlc3QSIAoYbG9jYWxfcGFydGlj", - "aXBhbnRfaGFuZGxlGAEgAigEEhwKFHBhcnRpY2lwYW50X2lkZW50aXR5GAIg", - "AigJEhAKCHRyYWNrX2lkGAMgAigJEjUKCHNlZ21lbnRzGAQgAygLMiMubGl2", - "ZWtpdC5wcm90by5UcmFuc2NyaXB0aW9uU2VnbWVudCIwChxQdWJsaXNoVHJh", - "bnNjcmlwdGlvblJlc3BvbnNlEhAKCGFzeW5jX2lkGAEgAigEIj8KHFB1Ymxp", - "c2hUcmFuc2NyaXB0aW9uQ2FsbGJhY2sSEAoIYXN5bmNfaWQYASACKAQSDQoF", - "ZXJyb3IYAiABKAkidgoVUHVibGlzaFNpcER0bWZSZXF1ZXN0EiAKGGxvY2Fs", - "X3BhcnRpY2lwYW50X2hhbmRsZRgBIAIoBBIMCgRjb2RlGAIgAigNEg0KBWRp", - "Z2l0GAMgAigJEh4KFmRlc3RpbmF0aW9uX2lkZW50aXRpZXMYBCADKAkiKgoW", - "UHVibGlzaFNpcER0bWZSZXNwb25zZRIQCghhc3luY19pZBgBIAIoBCI5ChZQ", - "dWJsaXNoU2lwRHRtZkNhbGxiYWNrEhAKCGFzeW5jX2lkGAEgAigEEg0KBWVy", - "cm9yGAIgASgJIk0KF1NldExvY2FsTWV0YWRhdGFSZXF1ZXN0EiAKGGxvY2Fs", - "X3BhcnRpY2lwYW50X2hhbmRsZRgBIAIoBBIQCghtZXRhZGF0YRgCIAIoCSIs", - "ChhTZXRMb2NhbE1ldGFkYXRhUmVzcG9uc2USEAoIYXN5bmNfaWQYASACKAQi", - "OwoYU2V0TG9jYWxNZXRhZGF0YUNhbGxiYWNrEhAKCGFzeW5jX2lkGAEgAigE", - "Eg0KBWVycm9yGAIgASgJIoQBChZTZW5kQ2hhdE1lc3NhZ2VSZXF1ZXN0EiAK", - "GGxvY2FsX3BhcnRpY2lwYW50X2hhbmRsZRgBIAIoBBIPCgdtZXNzYWdlGAIg", - "AigJEh4KFmRlc3RpbmF0aW9uX2lkZW50aXRpZXMYAyADKAkSFwoPc2VuZGVy", - "X2lkZW50aXR5GAQgASgJIrwBChZFZGl0Q2hhdE1lc3NhZ2VSZXF1ZXN0EiAK", - "GGxvY2FsX3BhcnRpY2lwYW50X2hhbmRsZRgBIAIoBBIRCgllZGl0X3RleHQY", - "AiACKAkSNAoQb3JpZ2luYWxfbWVzc2FnZRgDIAIoCzIaLmxpdmVraXQucHJv", - "dG8uQ2hhdE1lc3NhZ2USHgoWZGVzdGluYXRpb25faWRlbnRpdGllcxgEIAMo", - "CRIXCg9zZW5kZXJfaWRlbnRpdHkYBSABKAkiKwoXU2VuZENoYXRNZXNzYWdl", - "UmVzcG9uc2USEAoIYXN5bmNfaWQYASACKAQiewoXU2VuZENoYXRNZXNzYWdl", - "Q2FsbGJhY2sSEAoIYXN5bmNfaWQYASACKAQSDwoFZXJyb3IYAiABKAlIABIy", - "CgxjaGF0X21lc3NhZ2UYAyABKAsyGi5saXZla2l0LnByb3RvLkNoYXRNZXNz", - "YWdlSABCCQoHbWVzc2FnZSJxChlTZXRMb2NhbEF0dHJpYnV0ZXNSZXF1ZXN0", - "EiAKGGxvY2FsX3BhcnRpY2lwYW50X2hhbmRsZRgBIAIoBBIyCgphdHRyaWJ1", - "dGVzGAIgAygLMh4ubGl2ZWtpdC5wcm90by5BdHRyaWJ1dGVzRW50cnkiLQoP", - "QXR0cmlidXRlc0VudHJ5EgsKA2tleRgBIAIoCRINCgV2YWx1ZRgCIAIoCSIu", - "ChpTZXRMb2NhbEF0dHJpYnV0ZXNSZXNwb25zZRIQCghhc3luY19pZBgBIAIo", - "BCI9ChpTZXRMb2NhbEF0dHJpYnV0ZXNDYWxsYmFjaxIQCghhc3luY19pZBgB", - "IAIoBBINCgVlcnJvchgCIAEoCSJFChNTZXRMb2NhbE5hbWVSZXF1ZXN0EiAK", - "GGxvY2FsX3BhcnRpY2lwYW50X2hhbmRsZRgBIAIoBBIMCgRuYW1lGAIgAigJ", - "IigKFFNldExvY2FsTmFtZVJlc3BvbnNlEhAKCGFzeW5jX2lkGAEgAigEIjcK", - "FFNldExvY2FsTmFtZUNhbGxiYWNrEhAKCGFzeW5jX2lkGAEgAigEEg0KBWVy", - "cm9yGAIgASgJIkUKFFNldFN1YnNjcmliZWRSZXF1ZXN0EhEKCXN1YnNjcmli", - "ZRgBIAIoCBIaChJwdWJsaWNhdGlvbl9oYW5kbGUYAiACKAQiFwoVU2V0U3Vi", - "c2NyaWJlZFJlc3BvbnNlIi0KFkdldFNlc3Npb25TdGF0c1JlcXVlc3QSEwoL", - "cm9vbV9oYW5kbGUYASACKAQiKwoXR2V0U2Vzc2lvblN0YXRzUmVzcG9uc2US", - "EAoIYXN5bmNfaWQYASACKAQi9wEKF0dldFNlc3Npb25TdGF0c0NhbGxiYWNr", - "EhAKCGFzeW5jX2lkGAEgAigEEg8KBWVycm9yGAIgASgJSAASPwoGcmVzdWx0", - "GAMgASgLMi0ubGl2ZWtpdC5wcm90by5HZXRTZXNzaW9uU3RhdHNDYWxsYmFj", - "ay5SZXN1bHRIABptCgZSZXN1bHQSMAoPcHVibGlzaGVyX3N0YXRzGAEgAygL", - "MhcubGl2ZWtpdC5wcm90by5SdGNTdGF0cxIxChBzdWJzY3JpYmVyX3N0YXRz", - "GAIgAygLMhcubGl2ZWtpdC5wcm90by5SdGNTdGF0c0IJCgdtZXNzYWdlIjsK", - "DVZpZGVvRW5jb2RpbmcSEwoLbWF4X2JpdHJhdGUYASACKAQSFQoNbWF4X2Zy", - "YW1lcmF0ZRgCIAIoASIkCg1BdWRpb0VuY29kaW5nEhMKC21heF9iaXRyYXRl", - "GAEgAigEIpoCChNUcmFja1B1Ymxpc2hPcHRpb25zEjQKDnZpZGVvX2VuY29k", - "aW5nGAEgASgLMhwubGl2ZWtpdC5wcm90by5WaWRlb0VuY29kaW5nEjQKDmF1", - "ZGlvX2VuY29kaW5nGAIgASgLMhwubGl2ZWtpdC5wcm90by5BdWRpb0VuY29k", - "aW5nEi4KC3ZpZGVvX2NvZGVjGAMgASgOMhkubGl2ZWtpdC5wcm90by5WaWRl", - "b0NvZGVjEgsKA2R0eBgEIAEoCBILCgNyZWQYBSABKAgSEQoJc2ltdWxjYXN0", - "GAYgASgIEioKBnNvdXJjZRgHIAEoDjIaLmxpdmVraXQucHJvdG8uVHJhY2tT", - "b3VyY2USDgoGc3RyZWFtGAggASgJIj0KCUljZVNlcnZlchIMCgR1cmxzGAEg", - "AygJEhAKCHVzZXJuYW1lGAIgASgJEhAKCHBhc3N3b3JkGAMgASgJIsQBCglS", - "dGNDb25maWcSOwoSaWNlX3RyYW5zcG9ydF90eXBlGAEgASgOMh8ubGl2ZWtp", - "dC5wcm90by5JY2VUcmFuc3BvcnRUeXBlEksKGmNvbnRpbnVhbF9nYXRoZXJp", - "bmdfcG9saWN5GAIgASgOMicubGl2ZWtpdC5wcm90by5Db250aW51YWxHYXRo", - "ZXJpbmdQb2xpY3kSLQoLaWNlX3NlcnZlcnMYAyADKAsyGC5saXZla2l0LnBy", - "b3RvLkljZVNlcnZlciK+AQoLUm9vbU9wdGlvbnMSFgoOYXV0b19zdWJzY3Jp", - "YmUYASABKAgSFwoPYWRhcHRpdmVfc3RyZWFtGAIgASgIEhAKCGR5bmFjYXN0", - "GAMgASgIEigKBGUyZWUYBCABKAsyGi5saXZla2l0LnByb3RvLkUyZWVPcHRp", - "b25zEiwKCnJ0Y19jb25maWcYBSABKAsyGC5saXZla2l0LnByb3RvLlJ0Y0Nv", - "bmZpZxIUCgxqb2luX3JldHJpZXMYBiABKA0idwoUVHJhbnNjcmlwdGlvblNl", - "Z21lbnQSCgoCaWQYASACKAkSDAoEdGV4dBgCIAIoCRISCgpzdGFydF90aW1l", - "GAMgAigEEhAKCGVuZF90aW1lGAQgAigEEg0KBWZpbmFsGAUgAigIEhAKCGxh", - "bmd1YWdlGAYgAigJIjAKCkJ1ZmZlckluZm8SEAoIZGF0YV9wdHIYASACKAQS", - "EAoIZGF0YV9sZW4YAiACKAQiZQoLT3duZWRCdWZmZXISLQoGaGFuZGxlGAEg", - "AigLMh0ubGl2ZWtpdC5wcm90by5GZmlPd25lZEhhbmRsZRInCgRkYXRhGAIg", - "AigLMhkubGl2ZWtpdC5wcm90by5CdWZmZXJJbmZvIt0OCglSb29tRXZlbnQS", - "EwoLcm9vbV9oYW5kbGUYASACKAQSRAoVcGFydGljaXBhbnRfY29ubmVjdGVk", - "GAIgASgLMiMubGl2ZWtpdC5wcm90by5QYXJ0aWNpcGFudENvbm5lY3RlZEgA", - "EkoKGHBhcnRpY2lwYW50X2Rpc2Nvbm5lY3RlZBgDIAEoCzImLmxpdmVraXQu", - "cHJvdG8uUGFydGljaXBhbnREaXNjb25uZWN0ZWRIABJDChVsb2NhbF90cmFj", - "a19wdWJsaXNoZWQYBCABKAsyIi5saXZla2l0LnByb3RvLkxvY2FsVHJhY2tQ", - "dWJsaXNoZWRIABJHChdsb2NhbF90cmFja191bnB1Ymxpc2hlZBgFIAEoCzIk", - "LmxpdmVraXQucHJvdG8uTG9jYWxUcmFja1VucHVibGlzaGVkSAASRQoWbG9j", - "YWxfdHJhY2tfc3Vic2NyaWJlZBgGIAEoCzIjLmxpdmVraXQucHJvdG8uTG9j", - "YWxUcmFja1N1YnNjcmliZWRIABI4Cg90cmFja19wdWJsaXNoZWQYByABKAsy", - "HS5saXZla2l0LnByb3RvLlRyYWNrUHVibGlzaGVkSAASPAoRdHJhY2tfdW5w", - "dWJsaXNoZWQYCCABKAsyHy5saXZla2l0LnByb3RvLlRyYWNrVW5wdWJsaXNo", - "ZWRIABI6ChB0cmFja19zdWJzY3JpYmVkGAkgASgLMh4ubGl2ZWtpdC5wcm90", - "by5UcmFja1N1YnNjcmliZWRIABI+ChJ0cmFja191bnN1YnNjcmliZWQYCiAB", - "KAsyIC5saXZla2l0LnByb3RvLlRyYWNrVW5zdWJzY3JpYmVkSAASSwoZdHJh", - "Y2tfc3Vic2NyaXB0aW9uX2ZhaWxlZBgLIAEoCzImLmxpdmVraXQucHJvdG8u", - "VHJhY2tTdWJzY3JpcHRpb25GYWlsZWRIABIwCgt0cmFja19tdXRlZBgMIAEo", - "CzIZLmxpdmVraXQucHJvdG8uVHJhY2tNdXRlZEgAEjQKDXRyYWNrX3VubXV0", - "ZWQYDSABKAsyGy5saXZla2l0LnByb3RvLlRyYWNrVW5tdXRlZEgAEkcKF2Fj", - "dGl2ZV9zcGVha2Vyc19jaGFuZ2VkGA4gASgLMiQubGl2ZWtpdC5wcm90by5B", - "Y3RpdmVTcGVha2Vyc0NoYW5nZWRIABJDChVyb29tX21ldGFkYXRhX2NoYW5n", - "ZWQYDyABKAsyIi5saXZla2l0LnByb3RvLlJvb21NZXRhZGF0YUNoYW5nZWRI", - "ABI5ChByb29tX3NpZF9jaGFuZ2VkGBAgASgLMh0ubGl2ZWtpdC5wcm90by5S", - "b29tU2lkQ2hhbmdlZEgAElEKHHBhcnRpY2lwYW50X21ldGFkYXRhX2NoYW5n", - "ZWQYESABKAsyKS5saXZla2l0LnByb3RvLlBhcnRpY2lwYW50TWV0YWRhdGFD", - "aGFuZ2VkSAASSQoYcGFydGljaXBhbnRfbmFtZV9jaGFuZ2VkGBIgASgLMiUu", - "bGl2ZWtpdC5wcm90by5QYXJ0aWNpcGFudE5hbWVDaGFuZ2VkSAASVQoecGFy", - "dGljaXBhbnRfYXR0cmlidXRlc19jaGFuZ2VkGBMgASgLMisubGl2ZWtpdC5w", - "cm90by5QYXJ0aWNpcGFudEF0dHJpYnV0ZXNDaGFuZ2VkSAASTQoaY29ubmVj", - "dGlvbl9xdWFsaXR5X2NoYW5nZWQYFCABKAsyJy5saXZla2l0LnByb3RvLkNv", - "bm5lY3Rpb25RdWFsaXR5Q2hhbmdlZEgAEkkKGGNvbm5lY3Rpb25fc3RhdGVf", - "Y2hhbmdlZBgVIAEoCzIlLmxpdmVraXQucHJvdG8uQ29ubmVjdGlvblN0YXRl", - "Q2hhbmdlZEgAEjMKDGRpc2Nvbm5lY3RlZBgWIAEoCzIbLmxpdmVraXQucHJv", - "dG8uRGlzY29ubmVjdGVkSAASMwoMcmVjb25uZWN0aW5nGBcgASgLMhsubGl2", - "ZWtpdC5wcm90by5SZWNvbm5lY3RpbmdIABIxCgtyZWNvbm5lY3RlZBgYIAEo", - "CzIaLmxpdmVraXQucHJvdG8uUmVjb25uZWN0ZWRIABI9ChJlMmVlX3N0YXRl", - "X2NoYW5nZWQYGSABKAsyHy5saXZla2l0LnByb3RvLkUyZWVTdGF0ZUNoYW5n", - "ZWRIABIlCgNlb3MYGiABKAsyFi5saXZla2l0LnByb3RvLlJvb21FT1NIABJB", - "ChRkYXRhX3BhY2tldF9yZWNlaXZlZBgbIAEoCzIhLmxpdmVraXQucHJvdG8u", - "RGF0YVBhY2tldFJlY2VpdmVkSAASRgoWdHJhbnNjcmlwdGlvbl9yZWNlaXZl", - "ZBgcIAEoCzIkLmxpdmVraXQucHJvdG8uVHJhbnNjcmlwdGlvblJlY2VpdmVk", - "SAASOgoMY2hhdF9tZXNzYWdlGB0gASgLMiIubGl2ZWtpdC5wcm90by5DaGF0", - "TWVzc2FnZVJlY2VpdmVkSABCCQoHbWVzc2FnZSI3CghSb29tSW5mbxILCgNz", - "aWQYASABKAkSDAoEbmFtZRgCIAIoCRIQCghtZXRhZGF0YRgDIAIoCSJhCglP", - "d25lZFJvb20SLQoGaGFuZGxlGAEgAigLMh0ubGl2ZWtpdC5wcm90by5GZmlP", - "d25lZEhhbmRsZRIlCgRpbmZvGAIgAigLMhcubGl2ZWtpdC5wcm90by5Sb29t", - "SW5mbyJFChRQYXJ0aWNpcGFudENvbm5lY3RlZBItCgRpbmZvGAEgAigLMh8u", - "bGl2ZWtpdC5wcm90by5Pd25lZFBhcnRpY2lwYW50IjcKF1BhcnRpY2lwYW50", - "RGlzY29ubmVjdGVkEhwKFHBhcnRpY2lwYW50X2lkZW50aXR5GAEgAigJIigK", - "E0xvY2FsVHJhY2tQdWJsaXNoZWQSEQoJdHJhY2tfc2lkGAEgAigJIjAKFUxv", - "Y2FsVHJhY2tVbnB1Ymxpc2hlZBIXCg9wdWJsaWNhdGlvbl9zaWQYASACKAki", - "KQoUTG9jYWxUcmFja1N1YnNjcmliZWQSEQoJdHJhY2tfc2lkGAIgAigJImkK", - "DlRyYWNrUHVibGlzaGVkEhwKFHBhcnRpY2lwYW50X2lkZW50aXR5GAEgAigJ", - "EjkKC3B1YmxpY2F0aW9uGAIgAigLMiQubGl2ZWtpdC5wcm90by5Pd25lZFRy", - "YWNrUHVibGljYXRpb24iSQoQVHJhY2tVbnB1Ymxpc2hlZBIcChRwYXJ0aWNp", - "cGFudF9pZGVudGl0eRgBIAIoCRIXCg9wdWJsaWNhdGlvbl9zaWQYAiACKAki", - "WQoPVHJhY2tTdWJzY3JpYmVkEhwKFHBhcnRpY2lwYW50X2lkZW50aXR5GAEg", - "AigJEigKBXRyYWNrGAIgAigLMhkubGl2ZWtpdC5wcm90by5Pd25lZFRyYWNr", - "IkQKEVRyYWNrVW5zdWJzY3JpYmVkEhwKFHBhcnRpY2lwYW50X2lkZW50aXR5", - "GAEgAigJEhEKCXRyYWNrX3NpZBgCIAIoCSJZChdUcmFja1N1YnNjcmlwdGlv", - "bkZhaWxlZBIcChRwYXJ0aWNpcGFudF9pZGVudGl0eRgBIAIoCRIRCgl0cmFj", - "a19zaWQYAiACKAkSDQoFZXJyb3IYAyACKAkiPQoKVHJhY2tNdXRlZBIcChRw", - "YXJ0aWNpcGFudF9pZGVudGl0eRgBIAIoCRIRCgl0cmFja19zaWQYAiACKAki", - "PwoMVHJhY2tVbm11dGVkEhwKFHBhcnRpY2lwYW50X2lkZW50aXR5GAEgAigJ", - "EhEKCXRyYWNrX3NpZBgCIAIoCSJfChBFMmVlU3RhdGVDaGFuZ2VkEhwKFHBh", - "cnRpY2lwYW50X2lkZW50aXR5GAEgAigJEi0KBXN0YXRlGAIgAigOMh4ubGl2", - "ZWtpdC5wcm90by5FbmNyeXB0aW9uU3RhdGUiNwoVQWN0aXZlU3BlYWtlcnND", - "aGFuZ2VkEh4KFnBhcnRpY2lwYW50X2lkZW50aXRpZXMYASADKAkiJwoTUm9v", - "bU1ldGFkYXRhQ2hhbmdlZBIQCghtZXRhZGF0YRgBIAIoCSIdCg5Sb29tU2lk", - "Q2hhbmdlZBILCgNzaWQYASACKAkiTAoaUGFydGljaXBhbnRNZXRhZGF0YUNo", - "YW5nZWQSHAoUcGFydGljaXBhbnRfaWRlbnRpdHkYASACKAkSEAoIbWV0YWRh", - "dGEYAiACKAkirAEKHFBhcnRpY2lwYW50QXR0cmlidXRlc0NoYW5nZWQSHAoU", - "cGFydGljaXBhbnRfaWRlbnRpdHkYASACKAkSMgoKYXR0cmlidXRlcxgCIAMo", - "CzIeLmxpdmVraXQucHJvdG8uQXR0cmlidXRlc0VudHJ5EjoKEmNoYW5nZWRf", - "YXR0cmlidXRlcxgDIAMoCzIeLmxpdmVraXQucHJvdG8uQXR0cmlidXRlc0Vu", - "dHJ5IkQKFlBhcnRpY2lwYW50TmFtZUNoYW5nZWQSHAoUcGFydGljaXBhbnRf", - "aWRlbnRpdHkYASACKAkSDAoEbmFtZRgCIAIoCSJrChhDb25uZWN0aW9uUXVh", - "bGl0eUNoYW5nZWQSHAoUcGFydGljaXBhbnRfaWRlbnRpdHkYASACKAkSMQoH", - "cXVhbGl0eRgCIAIoDjIgLmxpdmVraXQucHJvdG8uQ29ubmVjdGlvblF1YWxp", - "dHkiRQoKVXNlclBhY2tldBIoCgRkYXRhGAEgAigLMhoubGl2ZWtpdC5wcm90", - "by5Pd25lZEJ1ZmZlchINCgV0b3BpYxgCIAEoCSJ5CgtDaGF0TWVzc2FnZRIK", - "CgJpZBgBIAIoCRIRCgl0aW1lc3RhbXAYAiACKAMSDwoHbWVzc2FnZRgDIAIo", - "CRIWCg5lZGl0X3RpbWVzdGFtcBgEIAEoAxIPCgdkZWxldGVkGAUgASgIEhEK", - "CWdlbmVyYXRlZBgGIAEoCCJgChNDaGF0TWVzc2FnZVJlY2VpdmVkEisKB21l", - "c3NhZ2UYASACKAsyGi5saXZla2l0LnByb3RvLkNoYXRNZXNzYWdlEhwKFHBh", - "cnRpY2lwYW50X2lkZW50aXR5GAIgAigJIiYKB1NpcERUTUYSDAoEY29kZRgB", - "IAIoDRINCgVkaWdpdBgCIAEoCSK/AQoSRGF0YVBhY2tldFJlY2VpdmVkEisK", - "BGtpbmQYASACKA4yHS5saXZla2l0LnByb3RvLkRhdGFQYWNrZXRLaW5kEhwK", - "FHBhcnRpY2lwYW50X2lkZW50aXR5GAIgAigJEikKBHVzZXIYBCABKAsyGS5s", - "aXZla2l0LnByb3RvLlVzZXJQYWNrZXRIABIqCghzaXBfZHRtZhgFIAEoCzIW", - "LmxpdmVraXQucHJvdG8uU2lwRFRNRkgAQgcKBXZhbHVlIn8KFVRyYW5zY3Jp", - "cHRpb25SZWNlaXZlZBIcChRwYXJ0aWNpcGFudF9pZGVudGl0eRgBIAEoCRIR", - "Cgl0cmFja19zaWQYAiABKAkSNQoIc2VnbWVudHMYAyADKAsyIy5saXZla2l0", - "LnByb3RvLlRyYW5zY3JpcHRpb25TZWdtZW50IkcKFkNvbm5lY3Rpb25TdGF0", - "ZUNoYW5nZWQSLQoFc3RhdGUYASACKA4yHi5saXZla2l0LnByb3RvLkNvbm5l", - "Y3Rpb25TdGF0ZSILCglDb25uZWN0ZWQiPwoMRGlzY29ubmVjdGVkEi8KBnJl", - "YXNvbhgBIAIoDjIfLmxpdmVraXQucHJvdG8uRGlzY29ubmVjdFJlYXNvbiIO", - "CgxSZWNvbm5lY3RpbmciDQoLUmVjb25uZWN0ZWQiCQoHUm9vbUVPUypQChBJ", - "Y2VUcmFuc3BvcnRUeXBlEhMKD1RSQU5TUE9SVF9SRUxBWRAAEhQKEFRSQU5T", - "UE9SVF9OT0hPU1QQARIRCg1UUkFOU1BPUlRfQUxMEAIqQwoYQ29udGludWFs", - "R2F0aGVyaW5nUG9saWN5Eg8KC0dBVEhFUl9PTkNFEAASFgoSR0FUSEVSX0NP", - "TlRJTlVBTExZEAEqYAoRQ29ubmVjdGlvblF1YWxpdHkSEAoMUVVBTElUWV9Q", - "T09SEAASEAoMUVVBTElUWV9HT09EEAESFQoRUVVBTElUWV9FWENFTExFTlQQ", - "AhIQCgxRVUFMSVRZX0xPU1QQAypTCg9Db25uZWN0aW9uU3RhdGUSFQoRQ09O", - "Tl9ESVNDT05ORUNURUQQABISCg5DT05OX0NPTk5FQ1RFRBABEhUKEUNPTk5f", - "UkVDT05ORUNUSU5HEAIqMwoORGF0YVBhY2tldEtpbmQSDgoKS0lORF9MT1NT", - "WRAAEhEKDUtJTkRfUkVMSUFCTEUQASrsAQoQRGlzY29ubmVjdFJlYXNvbhIS", - "Cg5VTktOT1dOX1JFQVNPThAAEhQKEENMSUVOVF9JTklUSUFURUQQARIWChJE", - "VVBMSUNBVEVfSURFTlRJVFkQAhITCg9TRVJWRVJfU0hVVERPV04QAxIXChNQ", - "QVJUSUNJUEFOVF9SRU1PVkVEEAQSEAoMUk9PTV9ERUxFVEVEEAUSEgoOU1RB", - "VEVfTUlTTUFUQ0gQBhIQCgxKT0lOX0ZBSUxVUkUQBxINCglNSUdSQVRJT04Q", - "CBIQCgxTSUdOQUxfQ0xPU0UQCRIPCgtST09NX0NMT1NFRBAKQhCqAg1MaXZl", - "S2l0LlByb3Rv")); + "ZW9fZnJhbWUucHJvdG8aC3N0YXRzLnByb3RvGhFkYXRhX3N0cmVhbS5wcm90", + "byJZCg5Db25uZWN0UmVxdWVzdBILCgN1cmwYASACKAkSDQoFdG9rZW4YAiAC", + "KAkSKwoHb3B0aW9ucxgDIAIoCzIaLmxpdmVraXQucHJvdG8uUm9vbU9wdGlv", + "bnMiIwoPQ29ubmVjdFJlc3BvbnNlEhAKCGFzeW5jX2lkGAEgAigEIr8DCg9D", + "b25uZWN0Q2FsbGJhY2sSEAoIYXN5bmNfaWQYASACKAQSDwoFZXJyb3IYAiAB", + "KAlIABI3CgZyZXN1bHQYAyABKAsyJS5saXZla2l0LnByb3RvLkNvbm5lY3RD", + "YWxsYmFjay5SZXN1bHRIABqJAQoVUGFydGljaXBhbnRXaXRoVHJhY2tzEjQK", + "C3BhcnRpY2lwYW50GAEgAigLMh8ubGl2ZWtpdC5wcm90by5Pd25lZFBhcnRp", + "Y2lwYW50EjoKDHB1YmxpY2F0aW9ucxgCIAMoCzIkLmxpdmVraXQucHJvdG8u", + "T3duZWRUcmFja1B1YmxpY2F0aW9uGrgBCgZSZXN1bHQSJgoEcm9vbRgBIAIo", + "CzIYLmxpdmVraXQucHJvdG8uT3duZWRSb29tEjoKEWxvY2FsX3BhcnRpY2lw", + "YW50GAIgAigLMh8ubGl2ZWtpdC5wcm90by5Pd25lZFBhcnRpY2lwYW50EkoK", + "DHBhcnRpY2lwYW50cxgDIAMoCzI0LmxpdmVraXQucHJvdG8uQ29ubmVjdENh", + "bGxiYWNrLlBhcnRpY2lwYW50V2l0aFRyYWNrc0IJCgdtZXNzYWdlIigKEURp", + "c2Nvbm5lY3RSZXF1ZXN0EhMKC3Jvb21faGFuZGxlGAEgAigEIiYKEkRpc2Nv", + "bm5lY3RSZXNwb25zZRIQCghhc3luY19pZBgBIAIoBCImChJEaXNjb25uZWN0", + "Q2FsbGJhY2sSEAoIYXN5bmNfaWQYASACKAQiggEKE1B1Ymxpc2hUcmFja1Jl", + "cXVlc3QSIAoYbG9jYWxfcGFydGljaXBhbnRfaGFuZGxlGAEgAigEEhQKDHRy", + "YWNrX2hhbmRsZRgCIAIoBBIzCgdvcHRpb25zGAMgAigLMiIubGl2ZWtpdC5w", + "cm90by5UcmFja1B1Ymxpc2hPcHRpb25zIigKFFB1Ymxpc2hUcmFja1Jlc3Bv", + "bnNlEhAKCGFzeW5jX2lkGAEgAigEIoEBChRQdWJsaXNoVHJhY2tDYWxsYmFj", + "axIQCghhc3luY19pZBgBIAIoBBIPCgVlcnJvchgCIAEoCUgAEjsKC3B1Ymxp", + "Y2F0aW9uGAMgASgLMiQubGl2ZWtpdC5wcm90by5Pd25lZFRyYWNrUHVibGlj", + "YXRpb25IAEIJCgdtZXNzYWdlImcKFVVucHVibGlzaFRyYWNrUmVxdWVzdBIg", + "Chhsb2NhbF9wYXJ0aWNpcGFudF9oYW5kbGUYASACKAQSEQoJdHJhY2tfc2lk", + "GAIgAigJEhkKEXN0b3Bfb25fdW5wdWJsaXNoGAMgAigIIioKFlVucHVibGlz", + "aFRyYWNrUmVzcG9uc2USEAoIYXN5bmNfaWQYASACKAQiOQoWVW5wdWJsaXNo", + "VHJhY2tDYWxsYmFjaxIQCghhc3luY19pZBgBIAIoBBINCgVlcnJvchgCIAEo", + "CSK5AQoSUHVibGlzaERhdGFSZXF1ZXN0EiAKGGxvY2FsX3BhcnRpY2lwYW50", + "X2hhbmRsZRgBIAIoBBIQCghkYXRhX3B0chgCIAIoBBIQCghkYXRhX2xlbhgD", + "IAIoBBIQCghyZWxpYWJsZRgEIAIoCBIcChBkZXN0aW5hdGlvbl9zaWRzGAUg", + "AygJQgIYARINCgV0b3BpYxgGIAEoCRIeChZkZXN0aW5hdGlvbl9pZGVudGl0", + "aWVzGAcgAygJIicKE1B1Ymxpc2hEYXRhUmVzcG9uc2USEAoIYXN5bmNfaWQY", + "ASACKAQiNgoTUHVibGlzaERhdGFDYWxsYmFjaxIQCghhc3luY19pZBgBIAIo", + "BBINCgVlcnJvchgCIAEoCSKmAQobUHVibGlzaFRyYW5zY3JpcHRpb25SZXF1", + "ZXN0EiAKGGxvY2FsX3BhcnRpY2lwYW50X2hhbmRsZRgBIAIoBBIcChRwYXJ0", + "aWNpcGFudF9pZGVudGl0eRgCIAIoCRIQCgh0cmFja19pZBgDIAIoCRI1Cghz", + "ZWdtZW50cxgEIAMoCzIjLmxpdmVraXQucHJvdG8uVHJhbnNjcmlwdGlvblNl", + "Z21lbnQiMAocUHVibGlzaFRyYW5zY3JpcHRpb25SZXNwb25zZRIQCghhc3lu", + "Y19pZBgBIAIoBCI/ChxQdWJsaXNoVHJhbnNjcmlwdGlvbkNhbGxiYWNrEhAK", + "CGFzeW5jX2lkGAEgAigEEg0KBWVycm9yGAIgASgJInYKFVB1Ymxpc2hTaXBE", + "dG1mUmVxdWVzdBIgChhsb2NhbF9wYXJ0aWNpcGFudF9oYW5kbGUYASACKAQS", + "DAoEY29kZRgCIAIoDRINCgVkaWdpdBgDIAIoCRIeChZkZXN0aW5hdGlvbl9p", + "ZGVudGl0aWVzGAQgAygJIioKFlB1Ymxpc2hTaXBEdG1mUmVzcG9uc2USEAoI", + "YXN5bmNfaWQYASACKAQiOQoWUHVibGlzaFNpcER0bWZDYWxsYmFjaxIQCghh", + "c3luY19pZBgBIAIoBBINCgVlcnJvchgCIAEoCSJNChdTZXRMb2NhbE1ldGFk", + "YXRhUmVxdWVzdBIgChhsb2NhbF9wYXJ0aWNpcGFudF9oYW5kbGUYASACKAQS", + "EAoIbWV0YWRhdGEYAiACKAkiLAoYU2V0TG9jYWxNZXRhZGF0YVJlc3BvbnNl", + "EhAKCGFzeW5jX2lkGAEgAigEIjsKGFNldExvY2FsTWV0YWRhdGFDYWxsYmFj", + "axIQCghhc3luY19pZBgBIAIoBBINCgVlcnJvchgCIAEoCSKEAQoWU2VuZENo", + "YXRNZXNzYWdlUmVxdWVzdBIgChhsb2NhbF9wYXJ0aWNpcGFudF9oYW5kbGUY", + "ASACKAQSDwoHbWVzc2FnZRgCIAIoCRIeChZkZXN0aW5hdGlvbl9pZGVudGl0", + "aWVzGAMgAygJEhcKD3NlbmRlcl9pZGVudGl0eRgEIAEoCSK8AQoWRWRpdENo", + "YXRNZXNzYWdlUmVxdWVzdBIgChhsb2NhbF9wYXJ0aWNpcGFudF9oYW5kbGUY", + "ASACKAQSEQoJZWRpdF90ZXh0GAIgAigJEjQKEG9yaWdpbmFsX21lc3NhZ2UY", + "AyACKAsyGi5saXZla2l0LnByb3RvLkNoYXRNZXNzYWdlEh4KFmRlc3RpbmF0", + "aW9uX2lkZW50aXRpZXMYBCADKAkSFwoPc2VuZGVyX2lkZW50aXR5GAUgASgJ", + "IisKF1NlbmRDaGF0TWVzc2FnZVJlc3BvbnNlEhAKCGFzeW5jX2lkGAEgAigE", + "InsKF1NlbmRDaGF0TWVzc2FnZUNhbGxiYWNrEhAKCGFzeW5jX2lkGAEgAigE", + "Eg8KBWVycm9yGAIgASgJSAASMgoMY2hhdF9tZXNzYWdlGAMgASgLMhoubGl2", + "ZWtpdC5wcm90by5DaGF0TWVzc2FnZUgAQgkKB21lc3NhZ2UicQoZU2V0TG9j", + "YWxBdHRyaWJ1dGVzUmVxdWVzdBIgChhsb2NhbF9wYXJ0aWNpcGFudF9oYW5k", + "bGUYASACKAQSMgoKYXR0cmlidXRlcxgCIAMoCzIeLmxpdmVraXQucHJvdG8u", + "QXR0cmlidXRlc0VudHJ5Ii0KD0F0dHJpYnV0ZXNFbnRyeRILCgNrZXkYASAC", + "KAkSDQoFdmFsdWUYAiACKAkiLgoaU2V0TG9jYWxBdHRyaWJ1dGVzUmVzcG9u", + "c2USEAoIYXN5bmNfaWQYASACKAQiPQoaU2V0TG9jYWxBdHRyaWJ1dGVzQ2Fs", + "bGJhY2sSEAoIYXN5bmNfaWQYASACKAQSDQoFZXJyb3IYAiABKAkiRQoTU2V0", + "TG9jYWxOYW1lUmVxdWVzdBIgChhsb2NhbF9wYXJ0aWNpcGFudF9oYW5kbGUY", + "ASACKAQSDAoEbmFtZRgCIAIoCSIoChRTZXRMb2NhbE5hbWVSZXNwb25zZRIQ", + "Cghhc3luY19pZBgBIAIoBCI3ChRTZXRMb2NhbE5hbWVDYWxsYmFjaxIQCghh", + "c3luY19pZBgBIAIoBBINCgVlcnJvchgCIAEoCSJFChRTZXRTdWJzY3JpYmVk", + "UmVxdWVzdBIRCglzdWJzY3JpYmUYASACKAgSGgoScHVibGljYXRpb25faGFu", + "ZGxlGAIgAigEIhcKFVNldFN1YnNjcmliZWRSZXNwb25zZSItChZHZXRTZXNz", + "aW9uU3RhdHNSZXF1ZXN0EhMKC3Jvb21faGFuZGxlGAEgAigEIisKF0dldFNl", + "c3Npb25TdGF0c1Jlc3BvbnNlEhAKCGFzeW5jX2lkGAEgAigEIvcBChdHZXRT", + "ZXNzaW9uU3RhdHNDYWxsYmFjaxIQCghhc3luY19pZBgBIAIoBBIPCgVlcnJv", + "chgCIAEoCUgAEj8KBnJlc3VsdBgDIAEoCzItLmxpdmVraXQucHJvdG8uR2V0", + "U2Vzc2lvblN0YXRzQ2FsbGJhY2suUmVzdWx0SAAabQoGUmVzdWx0EjAKD3B1", + "Ymxpc2hlcl9zdGF0cxgBIAMoCzIXLmxpdmVraXQucHJvdG8uUnRjU3RhdHMS", + "MQoQc3Vic2NyaWJlcl9zdGF0cxgCIAMoCzIXLmxpdmVraXQucHJvdG8uUnRj", + "U3RhdHNCCQoHbWVzc2FnZSI7Cg1WaWRlb0VuY29kaW5nEhMKC21heF9iaXRy", + "YXRlGAEgAigEEhUKDW1heF9mcmFtZXJhdGUYAiACKAEiJAoNQXVkaW9FbmNv", + "ZGluZxITCgttYXhfYml0cmF0ZRgBIAIoBCKaAgoTVHJhY2tQdWJsaXNoT3B0", + "aW9ucxI0Cg52aWRlb19lbmNvZGluZxgBIAEoCzIcLmxpdmVraXQucHJvdG8u", + "VmlkZW9FbmNvZGluZxI0Cg5hdWRpb19lbmNvZGluZxgCIAEoCzIcLmxpdmVr", + "aXQucHJvdG8uQXVkaW9FbmNvZGluZxIuCgt2aWRlb19jb2RlYxgDIAEoDjIZ", + "LmxpdmVraXQucHJvdG8uVmlkZW9Db2RlYxILCgNkdHgYBCABKAgSCwoDcmVk", + "GAUgASgIEhEKCXNpbXVsY2FzdBgGIAEoCBIqCgZzb3VyY2UYByABKA4yGi5s", + "aXZla2l0LnByb3RvLlRyYWNrU291cmNlEg4KBnN0cmVhbRgIIAEoCSI9CglJ", + "Y2VTZXJ2ZXISDAoEdXJscxgBIAMoCRIQCgh1c2VybmFtZRgCIAEoCRIQCghw", + "YXNzd29yZBgDIAEoCSLEAQoJUnRjQ29uZmlnEjsKEmljZV90cmFuc3BvcnRf", + "dHlwZRgBIAEoDjIfLmxpdmVraXQucHJvdG8uSWNlVHJhbnNwb3J0VHlwZRJL", + "Chpjb250aW51YWxfZ2F0aGVyaW5nX3BvbGljeRgCIAEoDjInLmxpdmVraXQu", + "cHJvdG8uQ29udGludWFsR2F0aGVyaW5nUG9saWN5Ei0KC2ljZV9zZXJ2ZXJz", + "GAMgAygLMhgubGl2ZWtpdC5wcm90by5JY2VTZXJ2ZXIivgEKC1Jvb21PcHRp", + "b25zEhYKDmF1dG9fc3Vic2NyaWJlGAEgASgIEhcKD2FkYXB0aXZlX3N0cmVh", + "bRgCIAEoCBIQCghkeW5hY2FzdBgDIAEoCBIoCgRlMmVlGAQgASgLMhoubGl2", + "ZWtpdC5wcm90by5FMmVlT3B0aW9ucxIsCgpydGNfY29uZmlnGAUgASgLMhgu", + "bGl2ZWtpdC5wcm90by5SdGNDb25maWcSFAoMam9pbl9yZXRyaWVzGAYgASgN", + "IncKFFRyYW5zY3JpcHRpb25TZWdtZW50EgoKAmlkGAEgAigJEgwKBHRleHQY", + "AiACKAkSEgoKc3RhcnRfdGltZRgDIAIoBBIQCghlbmRfdGltZRgEIAIoBBIN", + "CgVmaW5hbBgFIAIoCBIQCghsYW5ndWFnZRgGIAIoCSIwCgpCdWZmZXJJbmZv", + "EhAKCGRhdGFfcHRyGAEgAigEEhAKCGRhdGFfbGVuGAIgAigEImUKC093bmVk", + "QnVmZmVyEi0KBmhhbmRsZRgBIAIoCzIdLmxpdmVraXQucHJvdG8uRmZpT3du", + "ZWRIYW5kbGUSJwoEZGF0YRgCIAIoCzIZLmxpdmVraXQucHJvdG8uQnVmZmVy", + "SW5mbyKnEgoJUm9vbUV2ZW50EhMKC3Jvb21faGFuZGxlGAEgAigEEkQKFXBh", + "cnRpY2lwYW50X2Nvbm5lY3RlZBgCIAEoCzIjLmxpdmVraXQucHJvdG8uUGFy", + "dGljaXBhbnRDb25uZWN0ZWRIABJKChhwYXJ0aWNpcGFudF9kaXNjb25uZWN0", + "ZWQYAyABKAsyJi5saXZla2l0LnByb3RvLlBhcnRpY2lwYW50RGlzY29ubmVj", + "dGVkSAASQwoVbG9jYWxfdHJhY2tfcHVibGlzaGVkGAQgASgLMiIubGl2ZWtp", + "dC5wcm90by5Mb2NhbFRyYWNrUHVibGlzaGVkSAASRwoXbG9jYWxfdHJhY2tf", + "dW5wdWJsaXNoZWQYBSABKAsyJC5saXZla2l0LnByb3RvLkxvY2FsVHJhY2tV", + "bnB1Ymxpc2hlZEgAEkUKFmxvY2FsX3RyYWNrX3N1YnNjcmliZWQYBiABKAsy", + "Iy5saXZla2l0LnByb3RvLkxvY2FsVHJhY2tTdWJzY3JpYmVkSAASOAoPdHJh", + "Y2tfcHVibGlzaGVkGAcgASgLMh0ubGl2ZWtpdC5wcm90by5UcmFja1B1Ymxp", + "c2hlZEgAEjwKEXRyYWNrX3VucHVibGlzaGVkGAggASgLMh8ubGl2ZWtpdC5w", + "cm90by5UcmFja1VucHVibGlzaGVkSAASOgoQdHJhY2tfc3Vic2NyaWJlZBgJ", + "IAEoCzIeLmxpdmVraXQucHJvdG8uVHJhY2tTdWJzY3JpYmVkSAASPgoSdHJh", + "Y2tfdW5zdWJzY3JpYmVkGAogASgLMiAubGl2ZWtpdC5wcm90by5UcmFja1Vu", + "c3Vic2NyaWJlZEgAEksKGXRyYWNrX3N1YnNjcmlwdGlvbl9mYWlsZWQYCyAB", + "KAsyJi5saXZla2l0LnByb3RvLlRyYWNrU3Vic2NyaXB0aW9uRmFpbGVkSAAS", + "MAoLdHJhY2tfbXV0ZWQYDCABKAsyGS5saXZla2l0LnByb3RvLlRyYWNrTXV0", + "ZWRIABI0Cg10cmFja191bm11dGVkGA0gASgLMhsubGl2ZWtpdC5wcm90by5U", + "cmFja1VubXV0ZWRIABJHChdhY3RpdmVfc3BlYWtlcnNfY2hhbmdlZBgOIAEo", + "CzIkLmxpdmVraXQucHJvdG8uQWN0aXZlU3BlYWtlcnNDaGFuZ2VkSAASQwoV", + "cm9vbV9tZXRhZGF0YV9jaGFuZ2VkGA8gASgLMiIubGl2ZWtpdC5wcm90by5S", + "b29tTWV0YWRhdGFDaGFuZ2VkSAASOQoQcm9vbV9zaWRfY2hhbmdlZBgQIAEo", + "CzIdLmxpdmVraXQucHJvdG8uUm9vbVNpZENoYW5nZWRIABJRChxwYXJ0aWNp", + "cGFudF9tZXRhZGF0YV9jaGFuZ2VkGBEgASgLMikubGl2ZWtpdC5wcm90by5Q", + "YXJ0aWNpcGFudE1ldGFkYXRhQ2hhbmdlZEgAEkkKGHBhcnRpY2lwYW50X25h", + "bWVfY2hhbmdlZBgSIAEoCzIlLmxpdmVraXQucHJvdG8uUGFydGljaXBhbnRO", + "YW1lQ2hhbmdlZEgAElUKHnBhcnRpY2lwYW50X2F0dHJpYnV0ZXNfY2hhbmdl", + "ZBgTIAEoCzIrLmxpdmVraXQucHJvdG8uUGFydGljaXBhbnRBdHRyaWJ1dGVz", + "Q2hhbmdlZEgAEk0KGmNvbm5lY3Rpb25fcXVhbGl0eV9jaGFuZ2VkGBQgASgL", + "MicubGl2ZWtpdC5wcm90by5Db25uZWN0aW9uUXVhbGl0eUNoYW5nZWRIABJJ", + "Chhjb25uZWN0aW9uX3N0YXRlX2NoYW5nZWQYFSABKAsyJS5saXZla2l0LnBy", + "b3RvLkNvbm5lY3Rpb25TdGF0ZUNoYW5nZWRIABIzCgxkaXNjb25uZWN0ZWQY", + "FiABKAsyGy5saXZla2l0LnByb3RvLkRpc2Nvbm5lY3RlZEgAEjMKDHJlY29u", + "bmVjdGluZxgXIAEoCzIbLmxpdmVraXQucHJvdG8uUmVjb25uZWN0aW5nSAAS", + "MQoLcmVjb25uZWN0ZWQYGCABKAsyGi5saXZla2l0LnByb3RvLlJlY29ubmVj", + "dGVkSAASPQoSZTJlZV9zdGF0ZV9jaGFuZ2VkGBkgASgLMh8ubGl2ZWtpdC5w", + "cm90by5FMmVlU3RhdGVDaGFuZ2VkSAASJQoDZW9zGBogASgLMhYubGl2ZWtp", + "dC5wcm90by5Sb29tRU9TSAASQQoUZGF0YV9wYWNrZXRfcmVjZWl2ZWQYGyAB", + "KAsyIS5saXZla2l0LnByb3RvLkRhdGFQYWNrZXRSZWNlaXZlZEgAEkYKFnRy", + "YW5zY3JpcHRpb25fcmVjZWl2ZWQYHCABKAsyJC5saXZla2l0LnByb3RvLlRy", + "YW5zY3JpcHRpb25SZWNlaXZlZEgAEjoKDGNoYXRfbWVzc2FnZRgdIAEoCzIi", + "LmxpdmVraXQucHJvdG8uQ2hhdE1lc3NhZ2VSZWNlaXZlZEgAEkkKFnN0cmVh", + "bV9oZWFkZXJfcmVjZWl2ZWQYHiABKAsyJy5saXZla2l0LnByb3RvLkRhdGFT", + "dHJlYW1IZWFkZXJSZWNlaXZlZEgAEkcKFXN0cmVhbV9jaHVua19yZWNlaXZl", + "ZBgfIAEoCzImLmxpdmVraXQucHJvdG8uRGF0YVN0cmVhbUNodW5rUmVjZWl2", + "ZWRIABJLChdzdHJlYW1fdHJhaWxlcl9yZWNlaXZlZBggIAEoCzIoLmxpdmVr", + "aXQucHJvdG8uRGF0YVN0cmVhbVRyYWlsZXJSZWNlaXZlZEgAEmkKImRhdGFf", + "Y2hhbm5lbF9sb3dfdGhyZXNob2xkX2NoYW5nZWQYISABKAsyOy5saXZla2l0", + "LnByb3RvLkRhdGFDaGFubmVsQnVmZmVyZWRBbW91bnRMb3dUaHJlc2hvbGRD", + "aGFuZ2VkSAASPQoSYnl0ZV9zdHJlYW1fb3BlbmVkGCIgASgLMh8ubGl2ZWtp", + "dC5wcm90by5CeXRlU3RyZWFtT3BlbmVkSAASPQoSdGV4dF9zdHJlYW1fb3Bl", + "bmVkGCMgASgLMh8ubGl2ZWtpdC5wcm90by5UZXh0U3RyZWFtT3BlbmVkSABC", + "CQoHbWVzc2FnZSKaAQoIUm9vbUluZm8SCwoDc2lkGAEgASgJEgwKBG5hbWUY", + "AiACKAkSEAoIbWV0YWRhdGEYAyACKAkSLgombG9zc3lfZGNfYnVmZmVyZWRf", + "YW1vdW50X2xvd190aHJlc2hvbGQYBCACKAQSMQopcmVsaWFibGVfZGNfYnVm", + "ZmVyZWRfYW1vdW50X2xvd190aHJlc2hvbGQYBSACKAQiYQoJT3duZWRSb29t", + "Ei0KBmhhbmRsZRgBIAIoCzIdLmxpdmVraXQucHJvdG8uRmZpT3duZWRIYW5k", + "bGUSJQoEaW5mbxgCIAIoCzIXLmxpdmVraXQucHJvdG8uUm9vbUluZm8iRQoU", + "UGFydGljaXBhbnRDb25uZWN0ZWQSLQoEaW5mbxgBIAIoCzIfLmxpdmVraXQu", + "cHJvdG8uT3duZWRQYXJ0aWNpcGFudCJzChdQYXJ0aWNpcGFudERpc2Nvbm5l", + "Y3RlZBIcChRwYXJ0aWNpcGFudF9pZGVudGl0eRgBIAIoCRI6ChFkaXNjb25u", + "ZWN0X3JlYXNvbhgCIAIoDjIfLmxpdmVraXQucHJvdG8uRGlzY29ubmVjdFJl", + "YXNvbiIoChNMb2NhbFRyYWNrUHVibGlzaGVkEhEKCXRyYWNrX3NpZBgBIAIo", + "CSIwChVMb2NhbFRyYWNrVW5wdWJsaXNoZWQSFwoPcHVibGljYXRpb25fc2lk", + "GAEgAigJIikKFExvY2FsVHJhY2tTdWJzY3JpYmVkEhEKCXRyYWNrX3NpZBgC", + "IAIoCSJpCg5UcmFja1B1Ymxpc2hlZBIcChRwYXJ0aWNpcGFudF9pZGVudGl0", + "eRgBIAIoCRI5CgtwdWJsaWNhdGlvbhgCIAIoCzIkLmxpdmVraXQucHJvdG8u", + "T3duZWRUcmFja1B1YmxpY2F0aW9uIkkKEFRyYWNrVW5wdWJsaXNoZWQSHAoU", + "cGFydGljaXBhbnRfaWRlbnRpdHkYASACKAkSFwoPcHVibGljYXRpb25fc2lk", + "GAIgAigJIlkKD1RyYWNrU3Vic2NyaWJlZBIcChRwYXJ0aWNpcGFudF9pZGVu", + "dGl0eRgBIAIoCRIoCgV0cmFjaxgCIAIoCzIZLmxpdmVraXQucHJvdG8uT3du", + "ZWRUcmFjayJEChFUcmFja1Vuc3Vic2NyaWJlZBIcChRwYXJ0aWNpcGFudF9p", + "ZGVudGl0eRgBIAIoCRIRCgl0cmFja19zaWQYAiACKAkiWQoXVHJhY2tTdWJz", + "Y3JpcHRpb25GYWlsZWQSHAoUcGFydGljaXBhbnRfaWRlbnRpdHkYASACKAkS", + "EQoJdHJhY2tfc2lkGAIgAigJEg0KBWVycm9yGAMgAigJIj0KClRyYWNrTXV0", + "ZWQSHAoUcGFydGljaXBhbnRfaWRlbnRpdHkYASACKAkSEQoJdHJhY2tfc2lk", + "GAIgAigJIj8KDFRyYWNrVW5tdXRlZBIcChRwYXJ0aWNpcGFudF9pZGVudGl0", + "eRgBIAIoCRIRCgl0cmFja19zaWQYAiACKAkiXwoQRTJlZVN0YXRlQ2hhbmdl", + "ZBIcChRwYXJ0aWNpcGFudF9pZGVudGl0eRgBIAIoCRItCgVzdGF0ZRgCIAIo", + "DjIeLmxpdmVraXQucHJvdG8uRW5jcnlwdGlvblN0YXRlIjcKFUFjdGl2ZVNw", + "ZWFrZXJzQ2hhbmdlZBIeChZwYXJ0aWNpcGFudF9pZGVudGl0aWVzGAEgAygJ", + "IicKE1Jvb21NZXRhZGF0YUNoYW5nZWQSEAoIbWV0YWRhdGEYASACKAkiHQoO", + "Um9vbVNpZENoYW5nZWQSCwoDc2lkGAEgAigJIkwKGlBhcnRpY2lwYW50TWV0", + "YWRhdGFDaGFuZ2VkEhwKFHBhcnRpY2lwYW50X2lkZW50aXR5GAEgAigJEhAK", + "CG1ldGFkYXRhGAIgAigJIqwBChxQYXJ0aWNpcGFudEF0dHJpYnV0ZXNDaGFu", + "Z2VkEhwKFHBhcnRpY2lwYW50X2lkZW50aXR5GAEgAigJEjIKCmF0dHJpYnV0", + "ZXMYAiADKAsyHi5saXZla2l0LnByb3RvLkF0dHJpYnV0ZXNFbnRyeRI6ChJj", + "aGFuZ2VkX2F0dHJpYnV0ZXMYAyADKAsyHi5saXZla2l0LnByb3RvLkF0dHJp", + "YnV0ZXNFbnRyeSJEChZQYXJ0aWNpcGFudE5hbWVDaGFuZ2VkEhwKFHBhcnRp", + "Y2lwYW50X2lkZW50aXR5GAEgAigJEgwKBG5hbWUYAiACKAkiawoYQ29ubmVj", + "dGlvblF1YWxpdHlDaGFuZ2VkEhwKFHBhcnRpY2lwYW50X2lkZW50aXR5GAEg", + "AigJEjEKB3F1YWxpdHkYAiACKA4yIC5saXZla2l0LnByb3RvLkNvbm5lY3Rp", + "b25RdWFsaXR5IkUKClVzZXJQYWNrZXQSKAoEZGF0YRgBIAIoCzIaLmxpdmVr", + "aXQucHJvdG8uT3duZWRCdWZmZXISDQoFdG9waWMYAiABKAkieQoLQ2hhdE1l", + "c3NhZ2USCgoCaWQYASACKAkSEQoJdGltZXN0YW1wGAIgAigDEg8KB21lc3Nh", + "Z2UYAyACKAkSFgoOZWRpdF90aW1lc3RhbXAYBCABKAMSDwoHZGVsZXRlZBgF", + "IAEoCBIRCglnZW5lcmF0ZWQYBiABKAgiYAoTQ2hhdE1lc3NhZ2VSZWNlaXZl", + "ZBIrCgdtZXNzYWdlGAEgAigLMhoubGl2ZWtpdC5wcm90by5DaGF0TWVzc2Fn", + "ZRIcChRwYXJ0aWNpcGFudF9pZGVudGl0eRgCIAIoCSImCgdTaXBEVE1GEgwK", + "BGNvZGUYASACKA0SDQoFZGlnaXQYAiABKAkivwEKEkRhdGFQYWNrZXRSZWNl", + "aXZlZBIrCgRraW5kGAEgAigOMh0ubGl2ZWtpdC5wcm90by5EYXRhUGFja2V0", + "S2luZBIcChRwYXJ0aWNpcGFudF9pZGVudGl0eRgCIAIoCRIpCgR1c2VyGAQg", + "ASgLMhkubGl2ZWtpdC5wcm90by5Vc2VyUGFja2V0SAASKgoIc2lwX2R0bWYY", + "BSABKAsyFi5saXZla2l0LnByb3RvLlNpcERUTUZIAEIHCgV2YWx1ZSJ/ChVU", + "cmFuc2NyaXB0aW9uUmVjZWl2ZWQSHAoUcGFydGljaXBhbnRfaWRlbnRpdHkY", + "ASABKAkSEQoJdHJhY2tfc2lkGAIgASgJEjUKCHNlZ21lbnRzGAMgAygLMiMu", + "bGl2ZWtpdC5wcm90by5UcmFuc2NyaXB0aW9uU2VnbWVudCJHChZDb25uZWN0", + "aW9uU3RhdGVDaGFuZ2VkEi0KBXN0YXRlGAEgAigOMh4ubGl2ZWtpdC5wcm90", + "by5Db25uZWN0aW9uU3RhdGUiCwoJQ29ubmVjdGVkIj8KDERpc2Nvbm5lY3Rl", + "ZBIvCgZyZWFzb24YASACKA4yHy5saXZla2l0LnByb3RvLkRpc2Nvbm5lY3RS", + "ZWFzb24iDgoMUmVjb25uZWN0aW5nIg0KC1JlY29ubmVjdGVkIgkKB1Jvb21F", + "T1MijgcKCkRhdGFTdHJlYW0aqgEKClRleHRIZWFkZXISPwoOb3BlcmF0aW9u", + "X3R5cGUYASACKA4yJy5saXZla2l0LnByb3RvLkRhdGFTdHJlYW0uT3BlcmF0", + "aW9uVHlwZRIPCgd2ZXJzaW9uGAIgASgFEhoKEnJlcGx5X3RvX3N0cmVhbV9p", + "ZBgDIAEoCRIbChNhdHRhY2hlZF9zdHJlYW1faWRzGAQgAygJEhEKCWdlbmVy", + "YXRlZBgFIAEoCBoaCgpCeXRlSGVhZGVyEgwKBG5hbWUYASACKAka6wIKBkhl", + "YWRlchIRCglzdHJlYW1faWQYASACKAkSEQoJdGltZXN0YW1wGAIgAigDEhEK", + "CW1pbWVfdHlwZRgDIAIoCRINCgV0b3BpYxgEIAIoCRIUCgx0b3RhbF9sZW5n", + "dGgYBSABKAQSRAoKYXR0cmlidXRlcxgGIAMoCzIwLmxpdmVraXQucHJvdG8u", + "RGF0YVN0cmVhbS5IZWFkZXIuQXR0cmlidXRlc0VudHJ5EjsKC3RleHRfaGVh", + "ZGVyGAcgASgLMiQubGl2ZWtpdC5wcm90by5EYXRhU3RyZWFtLlRleHRIZWFk", + "ZXJIABI7CgtieXRlX2hlYWRlchgIIAEoCzIkLmxpdmVraXQucHJvdG8uRGF0", + "YVN0cmVhbS5CeXRlSGVhZGVySAAaMQoPQXR0cmlidXRlc0VudHJ5EgsKA2tl", + "eRgBIAEoCRINCgV2YWx1ZRgCIAEoCToCOAFCEAoOY29udGVudF9oZWFkZXIa", + "XQoFQ2h1bmsSEQoJc3RyZWFtX2lkGAEgAigJEhMKC2NodW5rX2luZGV4GAIg", + "AigEEg8KB2NvbnRlbnQYAyACKAwSDwoHdmVyc2lvbhgEIAEoBRIKCgJpdhgF", + "IAEoDBqmAQoHVHJhaWxlchIRCglzdHJlYW1faWQYASACKAkSDgoGcmVhc29u", + "GAIgAigJEkUKCmF0dHJpYnV0ZXMYAyADKAsyMS5saXZla2l0LnByb3RvLkRh", + "dGFTdHJlYW0uVHJhaWxlci5BdHRyaWJ1dGVzRW50cnkaMQoPQXR0cmlidXRl", + "c0VudHJ5EgsKA2tleRgBIAEoCRINCgV2YWx1ZRgCIAEoCToCOAEiQQoNT3Bl", + "cmF0aW9uVHlwZRIKCgZDUkVBVEUQABIKCgZVUERBVEUQARIKCgZERUxFVEUQ", + "AhIMCghSRUFDVElPThADImoKGERhdGFTdHJlYW1IZWFkZXJSZWNlaXZlZBIc", + "ChRwYXJ0aWNpcGFudF9pZGVudGl0eRgBIAIoCRIwCgZoZWFkZXIYAiACKAsy", + "IC5saXZla2l0LnByb3RvLkRhdGFTdHJlYW0uSGVhZGVyImcKF0RhdGFTdHJl", + "YW1DaHVua1JlY2VpdmVkEhwKFHBhcnRpY2lwYW50X2lkZW50aXR5GAEgAigJ", + "Ei4KBWNodW5rGAIgAigLMh8ubGl2ZWtpdC5wcm90by5EYXRhU3RyZWFtLkNo", + "dW5rIm0KGURhdGFTdHJlYW1UcmFpbGVyUmVjZWl2ZWQSHAoUcGFydGljaXBh", + "bnRfaWRlbnRpdHkYASACKAkSMgoHdHJhaWxlchgCIAIoCzIhLmxpdmVraXQu", + "cHJvdG8uRGF0YVN0cmVhbS5UcmFpbGVyIqYBChdTZW5kU3RyZWFtSGVhZGVy", + "UmVxdWVzdBIgChhsb2NhbF9wYXJ0aWNpcGFudF9oYW5kbGUYASACKAQSMAoG", + "aGVhZGVyGAIgAigLMiAubGl2ZWtpdC5wcm90by5EYXRhU3RyZWFtLkhlYWRl", + "chIeChZkZXN0aW5hdGlvbl9pZGVudGl0aWVzGAMgAygJEhcKD3NlbmRlcl9p", + "ZGVudGl0eRgEIAIoCSKjAQoWU2VuZFN0cmVhbUNodW5rUmVxdWVzdBIgChhs", + "b2NhbF9wYXJ0aWNpcGFudF9oYW5kbGUYASACKAQSLgoFY2h1bmsYAiACKAsy", + "Hy5saXZla2l0LnByb3RvLkRhdGFTdHJlYW0uQ2h1bmsSHgoWZGVzdGluYXRp", + "b25faWRlbnRpdGllcxgDIAMoCRIXCg9zZW5kZXJfaWRlbnRpdHkYBCACKAki", + "qQEKGFNlbmRTdHJlYW1UcmFpbGVyUmVxdWVzdBIgChhsb2NhbF9wYXJ0aWNp", + "cGFudF9oYW5kbGUYASACKAQSMgoHdHJhaWxlchgCIAIoCzIhLmxpdmVraXQu", + "cHJvdG8uRGF0YVN0cmVhbS5UcmFpbGVyEh4KFmRlc3RpbmF0aW9uX2lkZW50", + "aXRpZXMYAyADKAkSFwoPc2VuZGVyX2lkZW50aXR5GAQgAigJIiwKGFNlbmRT", + "dHJlYW1IZWFkZXJSZXNwb25zZRIQCghhc3luY19pZBgBIAIoBCIrChdTZW5k", + "U3RyZWFtQ2h1bmtSZXNwb25zZRIQCghhc3luY19pZBgBIAIoBCItChlTZW5k", + "U3RyZWFtVHJhaWxlclJlc3BvbnNlEhAKCGFzeW5jX2lkGAEgAigEIjsKGFNl", + "bmRTdHJlYW1IZWFkZXJDYWxsYmFjaxIQCghhc3luY19pZBgBIAIoBBINCgVl", + "cnJvchgCIAEoCSI6ChdTZW5kU3RyZWFtQ2h1bmtDYWxsYmFjaxIQCghhc3lu", + "Y19pZBgBIAIoBBINCgVlcnJvchgCIAEoCSI8ChlTZW5kU3RyZWFtVHJhaWxl", + "ckNhbGxiYWNrEhAKCGFzeW5jX2lkGAEgAigEEg0KBWVycm9yGAIgASgJIpMB", + "Ci9TZXREYXRhQ2hhbm5lbEJ1ZmZlcmVkQW1vdW50TG93VGhyZXNob2xkUmVx", + "dWVzdBIgChhsb2NhbF9wYXJ0aWNpcGFudF9oYW5kbGUYASACKAQSEQoJdGhy", + "ZXNob2xkGAIgAigEEisKBGtpbmQYAyACKA4yHS5saXZla2l0LnByb3RvLkRh", + "dGFQYWNrZXRLaW5kIjIKMFNldERhdGFDaGFubmVsQnVmZmVyZWRBbW91bnRM", + "b3dUaHJlc2hvbGRSZXNwb25zZSJuCixEYXRhQ2hhbm5lbEJ1ZmZlcmVkQW1v", + "dW50TG93VGhyZXNob2xkQ2hhbmdlZBIrCgRraW5kGAEgAigOMh0ubGl2ZWtp", + "dC5wcm90by5EYXRhUGFja2V0S2luZBIRCgl0aHJlc2hvbGQYAiACKAQiZgoQ", + "Qnl0ZVN0cmVhbU9wZW5lZBI0CgZyZWFkZXIYASACKAsyJC5saXZla2l0LnBy", + "b3RvLk93bmVkQnl0ZVN0cmVhbVJlYWRlchIcChRwYXJ0aWNpcGFudF9pZGVu", + "dGl0eRgCIAIoCSJmChBUZXh0U3RyZWFtT3BlbmVkEjQKBnJlYWRlchgBIAIo", + "CzIkLmxpdmVraXQucHJvdG8uT3duZWRUZXh0U3RyZWFtUmVhZGVyEhwKFHBh", + "cnRpY2lwYW50X2lkZW50aXR5GAIgAigJKlAKEEljZVRyYW5zcG9ydFR5cGUS", + "EwoPVFJBTlNQT1JUX1JFTEFZEAASFAoQVFJBTlNQT1JUX05PSE9TVBABEhEK", + "DVRSQU5TUE9SVF9BTEwQAipDChhDb250aW51YWxHYXRoZXJpbmdQb2xpY3kS", + "DwoLR0FUSEVSX09OQ0UQABIWChJHQVRIRVJfQ09OVElOVUFMTFkQASpgChFD", + "b25uZWN0aW9uUXVhbGl0eRIQCgxRVUFMSVRZX1BPT1IQABIQCgxRVUFMSVRZ", + "X0dPT0QQARIVChFRVUFMSVRZX0VYQ0VMTEVOVBACEhAKDFFVQUxJVFlfTE9T", + "VBADKlMKD0Nvbm5lY3Rpb25TdGF0ZRIVChFDT05OX0RJU0NPTk5FQ1RFRBAA", + "EhIKDkNPTk5fQ09OTkVDVEVEEAESFQoRQ09OTl9SRUNPTk5FQ1RJTkcQAioz", + "Cg5EYXRhUGFja2V0S2luZBIOCgpLSU5EX0xPU1NZEAASEQoNS0lORF9SRUxJ", + "QUJMRRABQhCqAg1MaXZlS2l0LlByb3Rv")); descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData, - new pbr::FileDescriptor[] { global::LiveKit.Proto.E2EeReflection.Descriptor, global::LiveKit.Proto.HandleReflection.Descriptor, global::LiveKit.Proto.ParticipantReflection.Descriptor, global::LiveKit.Proto.TrackReflection.Descriptor, global::LiveKit.Proto.VideoFrameReflection.Descriptor, global::LiveKit.Proto.StatsReflection.Descriptor, }, - new pbr::GeneratedClrTypeInfo(new[] {typeof(global::LiveKit.Proto.IceTransportType), typeof(global::LiveKit.Proto.ContinualGatheringPolicy), typeof(global::LiveKit.Proto.ConnectionQuality), typeof(global::LiveKit.Proto.ConnectionState), typeof(global::LiveKit.Proto.DataPacketKind), typeof(global::LiveKit.Proto.DisconnectReason), }, null, new pbr::GeneratedClrTypeInfo[] { + new pbr::FileDescriptor[] { global::LiveKit.Proto.E2EeReflection.Descriptor, global::LiveKit.Proto.HandleReflection.Descriptor, global::LiveKit.Proto.ParticipantReflection.Descriptor, global::LiveKit.Proto.TrackReflection.Descriptor, global::LiveKit.Proto.VideoFrameReflection.Descriptor, global::LiveKit.Proto.StatsReflection.Descriptor, global::LiveKit.Proto.DataStreamReflection.Descriptor, }, + new pbr::GeneratedClrTypeInfo(new[] {typeof(global::LiveKit.Proto.IceTransportType), typeof(global::LiveKit.Proto.ContinualGatheringPolicy), typeof(global::LiveKit.Proto.ConnectionQuality), typeof(global::LiveKit.Proto.ConnectionState), typeof(global::LiveKit.Proto.DataPacketKind), }, null, new pbr::GeneratedClrTypeInfo[] { new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.ConnectRequest), global::LiveKit.Proto.ConnectRequest.Parser, new[]{ "Url", "Token", "Options" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.ConnectResponse), global::LiveKit.Proto.ConnectResponse.Parser, new[]{ "AsyncId" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.ConnectCallback), global::LiveKit.Proto.ConnectCallback.Parser, new[]{ "AsyncId", "Error", "Result" }, new[]{ "Message" }, null, null, new pbr::GeneratedClrTypeInfo[] { new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.ConnectCallback.Types.ParticipantWithTracks), global::LiveKit.Proto.ConnectCallback.Types.ParticipantWithTracks.Parser, new[]{ "Participant", "Publications" }, null, null, null, null), @@ -296,11 +362,11 @@ static RoomReflection() { new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.TranscriptionSegment), global::LiveKit.Proto.TranscriptionSegment.Parser, new[]{ "Id", "Text", "StartTime", "EndTime", "Final", "Language" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.BufferInfo), global::LiveKit.Proto.BufferInfo.Parser, new[]{ "DataPtr", "DataLen" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.OwnedBuffer), global::LiveKit.Proto.OwnedBuffer.Parser, new[]{ "Handle", "Data" }, null, null, null, null), - new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.RoomEvent), global::LiveKit.Proto.RoomEvent.Parser, new[]{ "RoomHandle", "ParticipantConnected", "ParticipantDisconnected", "LocalTrackPublished", "LocalTrackUnpublished", "LocalTrackSubscribed", "TrackPublished", "TrackUnpublished", "TrackSubscribed", "TrackUnsubscribed", "TrackSubscriptionFailed", "TrackMuted", "TrackUnmuted", "ActiveSpeakersChanged", "RoomMetadataChanged", "RoomSidChanged", "ParticipantMetadataChanged", "ParticipantNameChanged", "ParticipantAttributesChanged", "ConnectionQualityChanged", "ConnectionStateChanged", "Disconnected", "Reconnecting", "Reconnected", "E2EeStateChanged", "Eos", "DataPacketReceived", "TranscriptionReceived", "ChatMessage" }, new[]{ "Message" }, null, null, null), - new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.RoomInfo), global::LiveKit.Proto.RoomInfo.Parser, new[]{ "Sid", "Name", "Metadata" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.RoomEvent), global::LiveKit.Proto.RoomEvent.Parser, new[]{ "RoomHandle", "ParticipantConnected", "ParticipantDisconnected", "LocalTrackPublished", "LocalTrackUnpublished", "LocalTrackSubscribed", "TrackPublished", "TrackUnpublished", "TrackSubscribed", "TrackUnsubscribed", "TrackSubscriptionFailed", "TrackMuted", "TrackUnmuted", "ActiveSpeakersChanged", "RoomMetadataChanged", "RoomSidChanged", "ParticipantMetadataChanged", "ParticipantNameChanged", "ParticipantAttributesChanged", "ConnectionQualityChanged", "ConnectionStateChanged", "Disconnected", "Reconnecting", "Reconnected", "E2EeStateChanged", "Eos", "DataPacketReceived", "TranscriptionReceived", "ChatMessage", "StreamHeaderReceived", "StreamChunkReceived", "StreamTrailerReceived", "DataChannelLowThresholdChanged", "ByteStreamOpened", "TextStreamOpened" }, new[]{ "Message" }, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.RoomInfo), global::LiveKit.Proto.RoomInfo.Parser, new[]{ "Sid", "Name", "Metadata", "LossyDcBufferedAmountLowThreshold", "ReliableDcBufferedAmountLowThreshold" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.OwnedRoom), global::LiveKit.Proto.OwnedRoom.Parser, new[]{ "Handle", "Info" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.ParticipantConnected), global::LiveKit.Proto.ParticipantConnected.Parser, new[]{ "Info" }, null, null, null, null), - new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.ParticipantDisconnected), global::LiveKit.Proto.ParticipantDisconnected.Parser, new[]{ "ParticipantIdentity" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.ParticipantDisconnected), global::LiveKit.Proto.ParticipantDisconnected.Parser, new[]{ "ParticipantIdentity", "DisconnectReason" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.LocalTrackPublished), global::LiveKit.Proto.LocalTrackPublished.Parser, new[]{ "TrackSid" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.LocalTrackUnpublished), global::LiveKit.Proto.LocalTrackUnpublished.Parser, new[]{ "PublicationSid" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.LocalTrackSubscribed), global::LiveKit.Proto.LocalTrackSubscribed.Parser, new[]{ "TrackSid" }, null, null, null, null), @@ -330,7 +396,29 @@ static RoomReflection() { new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.Disconnected), global::LiveKit.Proto.Disconnected.Parser, new[]{ "Reason" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.Reconnecting), global::LiveKit.Proto.Reconnecting.Parser, null, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.Reconnected), global::LiveKit.Proto.Reconnected.Parser, null, null, null, null, null), - new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.RoomEOS), global::LiveKit.Proto.RoomEOS.Parser, null, null, null, null, null) + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.RoomEOS), global::LiveKit.Proto.RoomEOS.Parser, null, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.DataStream), global::LiveKit.Proto.DataStream.Parser, null, null, new[]{ typeof(global::LiveKit.Proto.DataStream.Types.OperationType) }, null, new pbr::GeneratedClrTypeInfo[] { new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.DataStream.Types.TextHeader), global::LiveKit.Proto.DataStream.Types.TextHeader.Parser, new[]{ "OperationType", "Version", "ReplyToStreamId", "AttachedStreamIds", "Generated" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.DataStream.Types.ByteHeader), global::LiveKit.Proto.DataStream.Types.ByteHeader.Parser, new[]{ "Name" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.DataStream.Types.Header), global::LiveKit.Proto.DataStream.Types.Header.Parser, new[]{ "StreamId", "Timestamp", "MimeType", "Topic", "TotalLength", "Attributes", "TextHeader", "ByteHeader" }, new[]{ "ContentHeader" }, null, null, new pbr::GeneratedClrTypeInfo[] { null, }), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.DataStream.Types.Chunk), global::LiveKit.Proto.DataStream.Types.Chunk.Parser, new[]{ "StreamId", "ChunkIndex", "Content", "Version", "Iv" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.DataStream.Types.Trailer), global::LiveKit.Proto.DataStream.Types.Trailer.Parser, new[]{ "StreamId", "Reason", "Attributes" }, null, null, null, new pbr::GeneratedClrTypeInfo[] { null, })}), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.DataStreamHeaderReceived), global::LiveKit.Proto.DataStreamHeaderReceived.Parser, new[]{ "ParticipantIdentity", "Header" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.DataStreamChunkReceived), global::LiveKit.Proto.DataStreamChunkReceived.Parser, new[]{ "ParticipantIdentity", "Chunk" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.DataStreamTrailerReceived), global::LiveKit.Proto.DataStreamTrailerReceived.Parser, new[]{ "ParticipantIdentity", "Trailer" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.SendStreamHeaderRequest), global::LiveKit.Proto.SendStreamHeaderRequest.Parser, new[]{ "LocalParticipantHandle", "Header", "DestinationIdentities", "SenderIdentity" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.SendStreamChunkRequest), global::LiveKit.Proto.SendStreamChunkRequest.Parser, new[]{ "LocalParticipantHandle", "Chunk", "DestinationIdentities", "SenderIdentity" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.SendStreamTrailerRequest), global::LiveKit.Proto.SendStreamTrailerRequest.Parser, new[]{ "LocalParticipantHandle", "Trailer", "DestinationIdentities", "SenderIdentity" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.SendStreamHeaderResponse), global::LiveKit.Proto.SendStreamHeaderResponse.Parser, new[]{ "AsyncId" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.SendStreamChunkResponse), global::LiveKit.Proto.SendStreamChunkResponse.Parser, new[]{ "AsyncId" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.SendStreamTrailerResponse), global::LiveKit.Proto.SendStreamTrailerResponse.Parser, new[]{ "AsyncId" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.SendStreamHeaderCallback), global::LiveKit.Proto.SendStreamHeaderCallback.Parser, new[]{ "AsyncId", "Error" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.SendStreamChunkCallback), global::LiveKit.Proto.SendStreamChunkCallback.Parser, new[]{ "AsyncId", "Error" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.SendStreamTrailerCallback), global::LiveKit.Proto.SendStreamTrailerCallback.Parser, new[]{ "AsyncId", "Error" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.SetDataChannelBufferedAmountLowThresholdRequest), global::LiveKit.Proto.SetDataChannelBufferedAmountLowThresholdRequest.Parser, new[]{ "LocalParticipantHandle", "Threshold", "Kind" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.SetDataChannelBufferedAmountLowThresholdResponse), global::LiveKit.Proto.SetDataChannelBufferedAmountLowThresholdResponse.Parser, null, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.DataChannelBufferedAmountLowThresholdChanged), global::LiveKit.Proto.DataChannelBufferedAmountLowThresholdChanged.Parser, new[]{ "Kind", "Threshold" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.ByteStreamOpened), global::LiveKit.Proto.ByteStreamOpened.Parser, new[]{ "Reader", "ParticipantIdentity" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.TextStreamOpened), global::LiveKit.Proto.TextStreamOpened.Parser, new[]{ "Reader", "ParticipantIdentity" }, null, null, null, null) })); } #endregion @@ -366,50 +454,6 @@ public enum DataPacketKind { [pbr::OriginalName("KIND_RELIABLE")] KindReliable = 1, } - public enum DisconnectReason { - [pbr::OriginalName("UNKNOWN_REASON")] UnknownReason = 0, - /// - /// the client initiated the disconnect - /// - [pbr::OriginalName("CLIENT_INITIATED")] ClientInitiated = 1, - /// - /// another participant with the same identity has joined the room - /// - [pbr::OriginalName("DUPLICATE_IDENTITY")] DuplicateIdentity = 2, - /// - /// the server instance is shutting down - /// - [pbr::OriginalName("SERVER_SHUTDOWN")] ServerShutdown = 3, - /// - /// RoomService.RemoveParticipant was called - /// - [pbr::OriginalName("PARTICIPANT_REMOVED")] ParticipantRemoved = 4, - /// - /// RoomService.DeleteRoom was called - /// - [pbr::OriginalName("ROOM_DELETED")] RoomDeleted = 5, - /// - /// the client is attempting to resume a session, but server is not aware of it - /// - [pbr::OriginalName("STATE_MISMATCH")] StateMismatch = 6, - /// - /// client was unable to connect fully - /// - [pbr::OriginalName("JOIN_FAILURE")] JoinFailure = 7, - /// - /// Cloud-only, the server requested Participant to migrate the connection elsewhere - /// - [pbr::OriginalName("MIGRATION")] Migration = 8, - /// - /// the signal websocket was closed unexpectedly - /// - [pbr::OriginalName("SIGNAL_CLOSE")] SignalClose = 9, - /// - /// the room was closed, due to all Standard and Ingress participants having left - /// - [pbr::OriginalName("ROOM_CLOSED")] RoomClosed = 10, - } - #endregion #region Messages @@ -15189,6 +15233,24 @@ public RoomEvent(RoomEvent other) : this() { case MessageOneofCase.ChatMessage: ChatMessage = other.ChatMessage.Clone(); break; + case MessageOneofCase.StreamHeaderReceived: + StreamHeaderReceived = other.StreamHeaderReceived.Clone(); + break; + case MessageOneofCase.StreamChunkReceived: + StreamChunkReceived = other.StreamChunkReceived.Clone(); + break; + case MessageOneofCase.StreamTrailerReceived: + StreamTrailerReceived = other.StreamTrailerReceived.Clone(); + break; + case MessageOneofCase.DataChannelLowThresholdChanged: + DataChannelLowThresholdChanged = other.DataChannelLowThresholdChanged.Clone(); + break; + case MessageOneofCase.ByteStreamOpened: + ByteStreamOpened = other.ByteStreamOpened.Clone(); + break; + case MessageOneofCase.TextStreamOpened: + TextStreamOpened = other.TextStreamOpened.Clone(); + break; } _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); @@ -15569,6 +15631,84 @@ public void ClearRoomHandle() { } } + /// Field number for the "stream_header_received" field. + public const int StreamHeaderReceivedFieldNumber = 30; + /// + /// Data stream (low level) + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.DataStreamHeaderReceived StreamHeaderReceived { + get { return messageCase_ == MessageOneofCase.StreamHeaderReceived ? (global::LiveKit.Proto.DataStreamHeaderReceived) message_ : null; } + set { + message_ = value; + messageCase_ = value == null ? MessageOneofCase.None : MessageOneofCase.StreamHeaderReceived; + } + } + + /// Field number for the "stream_chunk_received" field. + public const int StreamChunkReceivedFieldNumber = 31; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.DataStreamChunkReceived StreamChunkReceived { + get { return messageCase_ == MessageOneofCase.StreamChunkReceived ? (global::LiveKit.Proto.DataStreamChunkReceived) message_ : null; } + set { + message_ = value; + messageCase_ = value == null ? MessageOneofCase.None : MessageOneofCase.StreamChunkReceived; + } + } + + /// Field number for the "stream_trailer_received" field. + public const int StreamTrailerReceivedFieldNumber = 32; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.DataStreamTrailerReceived StreamTrailerReceived { + get { return messageCase_ == MessageOneofCase.StreamTrailerReceived ? (global::LiveKit.Proto.DataStreamTrailerReceived) message_ : null; } + set { + message_ = value; + messageCase_ = value == null ? MessageOneofCase.None : MessageOneofCase.StreamTrailerReceived; + } + } + + /// Field number for the "data_channel_low_threshold_changed" field. + public const int DataChannelLowThresholdChangedFieldNumber = 33; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.DataChannelBufferedAmountLowThresholdChanged DataChannelLowThresholdChanged { + get { return messageCase_ == MessageOneofCase.DataChannelLowThresholdChanged ? (global::LiveKit.Proto.DataChannelBufferedAmountLowThresholdChanged) message_ : null; } + set { + message_ = value; + messageCase_ = value == null ? MessageOneofCase.None : MessageOneofCase.DataChannelLowThresholdChanged; + } + } + + /// Field number for the "byte_stream_opened" field. + public const int ByteStreamOpenedFieldNumber = 34; + /// + /// Data stream (high level) + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.ByteStreamOpened ByteStreamOpened { + get { return messageCase_ == MessageOneofCase.ByteStreamOpened ? (global::LiveKit.Proto.ByteStreamOpened) message_ : null; } + set { + message_ = value; + messageCase_ = value == null ? MessageOneofCase.None : MessageOneofCase.ByteStreamOpened; + } + } + + /// Field number for the "text_stream_opened" field. + public const int TextStreamOpenedFieldNumber = 35; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.TextStreamOpened TextStreamOpened { + get { return messageCase_ == MessageOneofCase.TextStreamOpened ? (global::LiveKit.Proto.TextStreamOpened) message_ : null; } + set { + message_ = value; + messageCase_ = value == null ? MessageOneofCase.None : MessageOneofCase.TextStreamOpened; + } + } + private object message_; /// Enum of possible cases for the "message" oneof. public enum MessageOneofCase { @@ -15601,6 +15741,12 @@ public enum MessageOneofCase { DataPacketReceived = 27, TranscriptionReceived = 28, ChatMessage = 29, + StreamHeaderReceived = 30, + StreamChunkReceived = 31, + StreamTrailerReceived = 32, + DataChannelLowThresholdChanged = 33, + ByteStreamOpened = 34, + TextStreamOpened = 35, } private MessageOneofCase messageCase_ = MessageOneofCase.None; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -15660,6 +15806,12 @@ public bool Equals(RoomEvent other) { if (!object.Equals(DataPacketReceived, other.DataPacketReceived)) return false; if (!object.Equals(TranscriptionReceived, other.TranscriptionReceived)) return false; if (!object.Equals(ChatMessage, other.ChatMessage)) return false; + if (!object.Equals(StreamHeaderReceived, other.StreamHeaderReceived)) return false; + if (!object.Equals(StreamChunkReceived, other.StreamChunkReceived)) return false; + if (!object.Equals(StreamTrailerReceived, other.StreamTrailerReceived)) return false; + if (!object.Equals(DataChannelLowThresholdChanged, other.DataChannelLowThresholdChanged)) return false; + if (!object.Equals(ByteStreamOpened, other.ByteStreamOpened)) return false; + if (!object.Equals(TextStreamOpened, other.TextStreamOpened)) return false; if (MessageCase != other.MessageCase) return false; return Equals(_unknownFields, other._unknownFields); } @@ -15697,6 +15849,12 @@ public override int GetHashCode() { if (messageCase_ == MessageOneofCase.DataPacketReceived) hash ^= DataPacketReceived.GetHashCode(); if (messageCase_ == MessageOneofCase.TranscriptionReceived) hash ^= TranscriptionReceived.GetHashCode(); if (messageCase_ == MessageOneofCase.ChatMessage) hash ^= ChatMessage.GetHashCode(); + if (messageCase_ == MessageOneofCase.StreamHeaderReceived) hash ^= StreamHeaderReceived.GetHashCode(); + if (messageCase_ == MessageOneofCase.StreamChunkReceived) hash ^= StreamChunkReceived.GetHashCode(); + if (messageCase_ == MessageOneofCase.StreamTrailerReceived) hash ^= StreamTrailerReceived.GetHashCode(); + if (messageCase_ == MessageOneofCase.DataChannelLowThresholdChanged) hash ^= DataChannelLowThresholdChanged.GetHashCode(); + if (messageCase_ == MessageOneofCase.ByteStreamOpened) hash ^= ByteStreamOpened.GetHashCode(); + if (messageCase_ == MessageOneofCase.TextStreamOpened) hash ^= TextStreamOpened.GetHashCode(); hash ^= (int) messageCase_; if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); @@ -15832,6 +15990,30 @@ public void WriteTo(pb::CodedOutputStream output) { output.WriteRawTag(234, 1); output.WriteMessage(ChatMessage); } + if (messageCase_ == MessageOneofCase.StreamHeaderReceived) { + output.WriteRawTag(242, 1); + output.WriteMessage(StreamHeaderReceived); + } + if (messageCase_ == MessageOneofCase.StreamChunkReceived) { + output.WriteRawTag(250, 1); + output.WriteMessage(StreamChunkReceived); + } + if (messageCase_ == MessageOneofCase.StreamTrailerReceived) { + output.WriteRawTag(130, 2); + output.WriteMessage(StreamTrailerReceived); + } + if (messageCase_ == MessageOneofCase.DataChannelLowThresholdChanged) { + output.WriteRawTag(138, 2); + output.WriteMessage(DataChannelLowThresholdChanged); + } + if (messageCase_ == MessageOneofCase.ByteStreamOpened) { + output.WriteRawTag(146, 2); + output.WriteMessage(ByteStreamOpened); + } + if (messageCase_ == MessageOneofCase.TextStreamOpened) { + output.WriteRawTag(154, 2); + output.WriteMessage(TextStreamOpened); + } if (_unknownFields != null) { _unknownFields.WriteTo(output); } @@ -15958,6 +16140,30 @@ public void WriteTo(pb::CodedOutputStream output) { output.WriteRawTag(234, 1); output.WriteMessage(ChatMessage); } + if (messageCase_ == MessageOneofCase.StreamHeaderReceived) { + output.WriteRawTag(242, 1); + output.WriteMessage(StreamHeaderReceived); + } + if (messageCase_ == MessageOneofCase.StreamChunkReceived) { + output.WriteRawTag(250, 1); + output.WriteMessage(StreamChunkReceived); + } + if (messageCase_ == MessageOneofCase.StreamTrailerReceived) { + output.WriteRawTag(130, 2); + output.WriteMessage(StreamTrailerReceived); + } + if (messageCase_ == MessageOneofCase.DataChannelLowThresholdChanged) { + output.WriteRawTag(138, 2); + output.WriteMessage(DataChannelLowThresholdChanged); + } + if (messageCase_ == MessageOneofCase.ByteStreamOpened) { + output.WriteRawTag(146, 2); + output.WriteMessage(ByteStreamOpened); + } + if (messageCase_ == MessageOneofCase.TextStreamOpened) { + output.WriteRawTag(154, 2); + output.WriteMessage(TextStreamOpened); + } if (_unknownFields != null) { _unknownFields.WriteTo(ref output); } @@ -16055,6 +16261,24 @@ public int CalculateSize() { if (messageCase_ == MessageOneofCase.ChatMessage) { size += 2 + pb::CodedOutputStream.ComputeMessageSize(ChatMessage); } + if (messageCase_ == MessageOneofCase.StreamHeaderReceived) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(StreamHeaderReceived); + } + if (messageCase_ == MessageOneofCase.StreamChunkReceived) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(StreamChunkReceived); + } + if (messageCase_ == MessageOneofCase.StreamTrailerReceived) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(StreamTrailerReceived); + } + if (messageCase_ == MessageOneofCase.DataChannelLowThresholdChanged) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(DataChannelLowThresholdChanged); + } + if (messageCase_ == MessageOneofCase.ByteStreamOpened) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(ByteStreamOpened); + } + if (messageCase_ == MessageOneofCase.TextStreamOpened) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(TextStreamOpened); + } if (_unknownFields != null) { size += _unknownFields.CalculateSize(); } @@ -16239,6 +16463,42 @@ public void MergeFrom(RoomEvent other) { } ChatMessage.MergeFrom(other.ChatMessage); break; + case MessageOneofCase.StreamHeaderReceived: + if (StreamHeaderReceived == null) { + StreamHeaderReceived = new global::LiveKit.Proto.DataStreamHeaderReceived(); + } + StreamHeaderReceived.MergeFrom(other.StreamHeaderReceived); + break; + case MessageOneofCase.StreamChunkReceived: + if (StreamChunkReceived == null) { + StreamChunkReceived = new global::LiveKit.Proto.DataStreamChunkReceived(); + } + StreamChunkReceived.MergeFrom(other.StreamChunkReceived); + break; + case MessageOneofCase.StreamTrailerReceived: + if (StreamTrailerReceived == null) { + StreamTrailerReceived = new global::LiveKit.Proto.DataStreamTrailerReceived(); + } + StreamTrailerReceived.MergeFrom(other.StreamTrailerReceived); + break; + case MessageOneofCase.DataChannelLowThresholdChanged: + if (DataChannelLowThresholdChanged == null) { + DataChannelLowThresholdChanged = new global::LiveKit.Proto.DataChannelBufferedAmountLowThresholdChanged(); + } + DataChannelLowThresholdChanged.MergeFrom(other.DataChannelLowThresholdChanged); + break; + case MessageOneofCase.ByteStreamOpened: + if (ByteStreamOpened == null) { + ByteStreamOpened = new global::LiveKit.Proto.ByteStreamOpened(); + } + ByteStreamOpened.MergeFrom(other.ByteStreamOpened); + break; + case MessageOneofCase.TextStreamOpened: + if (TextStreamOpened == null) { + TextStreamOpened = new global::LiveKit.Proto.TextStreamOpened(); + } + TextStreamOpened.MergeFrom(other.TextStreamOpened); + break; } _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); @@ -16516,6 +16776,60 @@ public void MergeFrom(pb::CodedInputStream input) { ChatMessage = subBuilder; break; } + case 242: { + global::LiveKit.Proto.DataStreamHeaderReceived subBuilder = new global::LiveKit.Proto.DataStreamHeaderReceived(); + if (messageCase_ == MessageOneofCase.StreamHeaderReceived) { + subBuilder.MergeFrom(StreamHeaderReceived); + } + input.ReadMessage(subBuilder); + StreamHeaderReceived = subBuilder; + break; + } + case 250: { + global::LiveKit.Proto.DataStreamChunkReceived subBuilder = new global::LiveKit.Proto.DataStreamChunkReceived(); + if (messageCase_ == MessageOneofCase.StreamChunkReceived) { + subBuilder.MergeFrom(StreamChunkReceived); + } + input.ReadMessage(subBuilder); + StreamChunkReceived = subBuilder; + break; + } + case 258: { + global::LiveKit.Proto.DataStreamTrailerReceived subBuilder = new global::LiveKit.Proto.DataStreamTrailerReceived(); + if (messageCase_ == MessageOneofCase.StreamTrailerReceived) { + subBuilder.MergeFrom(StreamTrailerReceived); + } + input.ReadMessage(subBuilder); + StreamTrailerReceived = subBuilder; + break; + } + case 266: { + global::LiveKit.Proto.DataChannelBufferedAmountLowThresholdChanged subBuilder = new global::LiveKit.Proto.DataChannelBufferedAmountLowThresholdChanged(); + if (messageCase_ == MessageOneofCase.DataChannelLowThresholdChanged) { + subBuilder.MergeFrom(DataChannelLowThresholdChanged); + } + input.ReadMessage(subBuilder); + DataChannelLowThresholdChanged = subBuilder; + break; + } + case 274: { + global::LiveKit.Proto.ByteStreamOpened subBuilder = new global::LiveKit.Proto.ByteStreamOpened(); + if (messageCase_ == MessageOneofCase.ByteStreamOpened) { + subBuilder.MergeFrom(ByteStreamOpened); + } + input.ReadMessage(subBuilder); + ByteStreamOpened = subBuilder; + break; + } + case 282: { + global::LiveKit.Proto.TextStreamOpened subBuilder = new global::LiveKit.Proto.TextStreamOpened(); + if (messageCase_ == MessageOneofCase.TextStreamOpened) { + subBuilder.MergeFrom(TextStreamOpened); + } + input.ReadMessage(subBuilder); + TextStreamOpened = subBuilder; + break; + } } } #endif @@ -16791,6 +17105,60 @@ public void MergeFrom(pb::CodedInputStream input) { ChatMessage = subBuilder; break; } + case 242: { + global::LiveKit.Proto.DataStreamHeaderReceived subBuilder = new global::LiveKit.Proto.DataStreamHeaderReceived(); + if (messageCase_ == MessageOneofCase.StreamHeaderReceived) { + subBuilder.MergeFrom(StreamHeaderReceived); + } + input.ReadMessage(subBuilder); + StreamHeaderReceived = subBuilder; + break; + } + case 250: { + global::LiveKit.Proto.DataStreamChunkReceived subBuilder = new global::LiveKit.Proto.DataStreamChunkReceived(); + if (messageCase_ == MessageOneofCase.StreamChunkReceived) { + subBuilder.MergeFrom(StreamChunkReceived); + } + input.ReadMessage(subBuilder); + StreamChunkReceived = subBuilder; + break; + } + case 258: { + global::LiveKit.Proto.DataStreamTrailerReceived subBuilder = new global::LiveKit.Proto.DataStreamTrailerReceived(); + if (messageCase_ == MessageOneofCase.StreamTrailerReceived) { + subBuilder.MergeFrom(StreamTrailerReceived); + } + input.ReadMessage(subBuilder); + StreamTrailerReceived = subBuilder; + break; + } + case 266: { + global::LiveKit.Proto.DataChannelBufferedAmountLowThresholdChanged subBuilder = new global::LiveKit.Proto.DataChannelBufferedAmountLowThresholdChanged(); + if (messageCase_ == MessageOneofCase.DataChannelLowThresholdChanged) { + subBuilder.MergeFrom(DataChannelLowThresholdChanged); + } + input.ReadMessage(subBuilder); + DataChannelLowThresholdChanged = subBuilder; + break; + } + case 274: { + global::LiveKit.Proto.ByteStreamOpened subBuilder = new global::LiveKit.Proto.ByteStreamOpened(); + if (messageCase_ == MessageOneofCase.ByteStreamOpened) { + subBuilder.MergeFrom(ByteStreamOpened); + } + input.ReadMessage(subBuilder); + ByteStreamOpened = subBuilder; + break; + } + case 282: { + global::LiveKit.Proto.TextStreamOpened subBuilder = new global::LiveKit.Proto.TextStreamOpened(); + if (messageCase_ == MessageOneofCase.TextStreamOpened) { + subBuilder.MergeFrom(TextStreamOpened); + } + input.ReadMessage(subBuilder); + TextStreamOpened = subBuilder; + break; + } } } } @@ -16806,6 +17174,7 @@ public sealed partial class RoomInfo : pb::IMessage { private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new RoomInfo()); private pb::UnknownFieldSet _unknownFields; + private int _hasBits0; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pb::MessageParser Parser { get { return _parser; } } @@ -16833,9 +17202,12 @@ public RoomInfo() { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public RoomInfo(RoomInfo other) : this() { + _hasBits0 = other._hasBits0; sid_ = other.sid_; name_ = other.name_; metadata_ = other.metadata_; + lossyDcBufferedAmountLowThreshold_ = other.lossyDcBufferedAmountLowThreshold_; + reliableDcBufferedAmountLowThreshold_ = other.reliableDcBufferedAmountLowThreshold_; _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); } @@ -16923,6 +17295,60 @@ public void ClearMetadata() { metadata_ = null; } + /// Field number for the "lossy_dc_buffered_amount_low_threshold" field. + public const int LossyDcBufferedAmountLowThresholdFieldNumber = 4; + private readonly static ulong LossyDcBufferedAmountLowThresholdDefaultValue = 0UL; + + private ulong lossyDcBufferedAmountLowThreshold_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ulong LossyDcBufferedAmountLowThreshold { + get { if ((_hasBits0 & 1) != 0) { return lossyDcBufferedAmountLowThreshold_; } else { return LossyDcBufferedAmountLowThresholdDefaultValue; } } + set { + _hasBits0 |= 1; + lossyDcBufferedAmountLowThreshold_ = value; + } + } + /// Gets whether the "lossy_dc_buffered_amount_low_threshold" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasLossyDcBufferedAmountLowThreshold { + get { return (_hasBits0 & 1) != 0; } + } + /// Clears the value of the "lossy_dc_buffered_amount_low_threshold" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearLossyDcBufferedAmountLowThreshold() { + _hasBits0 &= ~1; + } + + /// Field number for the "reliable_dc_buffered_amount_low_threshold" field. + public const int ReliableDcBufferedAmountLowThresholdFieldNumber = 5; + private readonly static ulong ReliableDcBufferedAmountLowThresholdDefaultValue = 0UL; + + private ulong reliableDcBufferedAmountLowThreshold_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ulong ReliableDcBufferedAmountLowThreshold { + get { if ((_hasBits0 & 2) != 0) { return reliableDcBufferedAmountLowThreshold_; } else { return ReliableDcBufferedAmountLowThresholdDefaultValue; } } + set { + _hasBits0 |= 2; + reliableDcBufferedAmountLowThreshold_ = value; + } + } + /// Gets whether the "reliable_dc_buffered_amount_low_threshold" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasReliableDcBufferedAmountLowThreshold { + get { return (_hasBits0 & 2) != 0; } + } + /// Clears the value of the "reliable_dc_buffered_amount_low_threshold" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearReliableDcBufferedAmountLowThreshold() { + _hasBits0 &= ~2; + } + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override bool Equals(object other) { @@ -16941,6 +17367,8 @@ public bool Equals(RoomInfo other) { if (Sid != other.Sid) return false; if (Name != other.Name) return false; if (Metadata != other.Metadata) return false; + if (LossyDcBufferedAmountLowThreshold != other.LossyDcBufferedAmountLowThreshold) return false; + if (ReliableDcBufferedAmountLowThreshold != other.ReliableDcBufferedAmountLowThreshold) return false; return Equals(_unknownFields, other._unknownFields); } @@ -16951,6 +17379,8 @@ public override int GetHashCode() { if (HasSid) hash ^= Sid.GetHashCode(); if (HasName) hash ^= Name.GetHashCode(); if (HasMetadata) hash ^= Metadata.GetHashCode(); + if (HasLossyDcBufferedAmountLowThreshold) hash ^= LossyDcBufferedAmountLowThreshold.GetHashCode(); + if (HasReliableDcBufferedAmountLowThreshold) hash ^= ReliableDcBufferedAmountLowThreshold.GetHashCode(); if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } @@ -16981,6 +17411,14 @@ public void WriteTo(pb::CodedOutputStream output) { output.WriteRawTag(26); output.WriteString(Metadata); } + if (HasLossyDcBufferedAmountLowThreshold) { + output.WriteRawTag(32); + output.WriteUInt64(LossyDcBufferedAmountLowThreshold); + } + if (HasReliableDcBufferedAmountLowThreshold) { + output.WriteRawTag(40); + output.WriteUInt64(ReliableDcBufferedAmountLowThreshold); + } if (_unknownFields != null) { _unknownFields.WriteTo(output); } @@ -17003,6 +17441,14 @@ public void WriteTo(pb::CodedOutputStream output) { output.WriteRawTag(26); output.WriteString(Metadata); } + if (HasLossyDcBufferedAmountLowThreshold) { + output.WriteRawTag(32); + output.WriteUInt64(LossyDcBufferedAmountLowThreshold); + } + if (HasReliableDcBufferedAmountLowThreshold) { + output.WriteRawTag(40); + output.WriteUInt64(ReliableDcBufferedAmountLowThreshold); + } if (_unknownFields != null) { _unknownFields.WriteTo(ref output); } @@ -17022,6 +17468,12 @@ public int CalculateSize() { if (HasMetadata) { size += 1 + pb::CodedOutputStream.ComputeStringSize(Metadata); } + if (HasLossyDcBufferedAmountLowThreshold) { + size += 1 + pb::CodedOutputStream.ComputeUInt64Size(LossyDcBufferedAmountLowThreshold); + } + if (HasReliableDcBufferedAmountLowThreshold) { + size += 1 + pb::CodedOutputStream.ComputeUInt64Size(ReliableDcBufferedAmountLowThreshold); + } if (_unknownFields != null) { size += _unknownFields.CalculateSize(); } @@ -17043,6 +17495,12 @@ public void MergeFrom(RoomInfo other) { if (other.HasMetadata) { Metadata = other.Metadata; } + if (other.HasLossyDcBufferedAmountLowThreshold) { + LossyDcBufferedAmountLowThreshold = other.LossyDcBufferedAmountLowThreshold; + } + if (other.HasReliableDcBufferedAmountLowThreshold) { + ReliableDcBufferedAmountLowThreshold = other.ReliableDcBufferedAmountLowThreshold; + } _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); } @@ -17074,6 +17532,14 @@ public void MergeFrom(pb::CodedInputStream input) { Metadata = input.ReadString(); break; } + case 32: { + LossyDcBufferedAmountLowThreshold = input.ReadUInt64(); + break; + } + case 40: { + ReliableDcBufferedAmountLowThreshold = input.ReadUInt64(); + break; + } } } #endif @@ -17105,6 +17571,14 @@ public void MergeFrom(pb::CodedInputStream input) { Metadata = input.ReadString(); break; } + case 32: { + LossyDcBufferedAmountLowThreshold = input.ReadUInt64(); + break; + } + case 40: { + ReliableDcBufferedAmountLowThreshold = input.ReadUInt64(); + break; + } } } } @@ -17580,6 +18054,7 @@ public sealed partial class ParticipantDisconnected : pb::IMessage _parser = new pb::MessageParser(() => new ParticipantDisconnected()); private pb::UnknownFieldSet _unknownFields; + private int _hasBits0; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pb::MessageParser Parser { get { return _parser; } } @@ -17607,7 +18082,9 @@ public ParticipantDisconnected() { [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public ParticipantDisconnected(ParticipantDisconnected other) : this() { + _hasBits0 = other._hasBits0; participantIdentity_ = other.participantIdentity_; + disconnectReason_ = other.disconnectReason_; _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); } @@ -17643,6 +18120,33 @@ public void ClearParticipantIdentity() { participantIdentity_ = null; } + /// Field number for the "disconnect_reason" field. + public const int DisconnectReasonFieldNumber = 2; + private readonly static global::LiveKit.Proto.DisconnectReason DisconnectReasonDefaultValue = global::LiveKit.Proto.DisconnectReason.UnknownReason; + + private global::LiveKit.Proto.DisconnectReason disconnectReason_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.DisconnectReason DisconnectReason { + get { if ((_hasBits0 & 1) != 0) { return disconnectReason_; } else { return DisconnectReasonDefaultValue; } } + set { + _hasBits0 |= 1; + disconnectReason_ = value; + } + } + /// Gets whether the "disconnect_reason" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasDisconnectReason { + get { return (_hasBits0 & 1) != 0; } + } + /// Clears the value of the "disconnect_reason" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearDisconnectReason() { + _hasBits0 &= ~1; + } + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public override bool Equals(object other) { @@ -17659,6 +18163,7 @@ public bool Equals(ParticipantDisconnected other) { return true; } if (ParticipantIdentity != other.ParticipantIdentity) return false; + if (DisconnectReason != other.DisconnectReason) return false; return Equals(_unknownFields, other._unknownFields); } @@ -17667,6 +18172,7 @@ public bool Equals(ParticipantDisconnected other) { public override int GetHashCode() { int hash = 1; if (HasParticipantIdentity) hash ^= ParticipantIdentity.GetHashCode(); + if (HasDisconnectReason) hash ^= DisconnectReason.GetHashCode(); if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } @@ -17689,6 +18195,10 @@ public void WriteTo(pb::CodedOutputStream output) { output.WriteRawTag(10); output.WriteString(ParticipantIdentity); } + if (HasDisconnectReason) { + output.WriteRawTag(16); + output.WriteEnum((int) DisconnectReason); + } if (_unknownFields != null) { _unknownFields.WriteTo(output); } @@ -17703,6 +18213,10 @@ public void WriteTo(pb::CodedOutputStream output) { output.WriteRawTag(10); output.WriteString(ParticipantIdentity); } + if (HasDisconnectReason) { + output.WriteRawTag(16); + output.WriteEnum((int) DisconnectReason); + } if (_unknownFields != null) { _unknownFields.WriteTo(ref output); } @@ -17716,6 +18230,9 @@ public int CalculateSize() { if (HasParticipantIdentity) { size += 1 + pb::CodedOutputStream.ComputeStringSize(ParticipantIdentity); } + if (HasDisconnectReason) { + size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) DisconnectReason); + } if (_unknownFields != null) { size += _unknownFields.CalculateSize(); } @@ -17731,6 +18248,9 @@ public void MergeFrom(ParticipantDisconnected other) { if (other.HasParticipantIdentity) { ParticipantIdentity = other.ParticipantIdentity; } + if (other.HasDisconnectReason) { + DisconnectReason = other.DisconnectReason; + } _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); } @@ -17754,6 +18274,10 @@ public void MergeFrom(pb::CodedInputStream input) { ParticipantIdentity = input.ReadString(); break; } + case 16: { + DisconnectReason = (global::LiveKit.Proto.DisconnectReason) input.ReadEnum(); + break; + } } } #endif @@ -17777,6 +18301,10 @@ public void MergeFrom(pb::CodedInputStream input) { ParticipantIdentity = input.ReadString(); break; } + case 16: { + DisconnectReason = (global::LiveKit.Proto.DisconnectReason) input.ReadEnum(); + break; + } } } } @@ -25269,6 +25797,6629 @@ public void MergeFrom(pb::CodedInputStream input) { } + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class DataStream : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new DataStream()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.RoomReflection.Descriptor.MessageTypes[84]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public DataStream() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public DataStream(DataStream other) : this() { + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public DataStream Clone() { + return new DataStream(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as DataStream); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(DataStream other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(DataStream other) { + if (other == null) { + return; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + } + } + } + #endif + + #region Nested types + /// Container for nested types declared in the DataStream message type. + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static partial class Types { + /// + /// enum for operation types (specific to TextHeader) + /// + public enum OperationType { + [pbr::OriginalName("CREATE")] Create = 0, + [pbr::OriginalName("UPDATE")] Update = 1, + [pbr::OriginalName("DELETE")] Delete = 2, + [pbr::OriginalName("REACTION")] Reaction = 3, + } + + /// + /// header properties specific to text streams + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class TextHeader : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new TextHeader()); + private pb::UnknownFieldSet _unknownFields; + private int _hasBits0; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.DataStream.Descriptor.NestedTypes[0]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TextHeader() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TextHeader(TextHeader other) : this() { + _hasBits0 = other._hasBits0; + operationType_ = other.operationType_; + version_ = other.version_; + replyToStreamId_ = other.replyToStreamId_; + attachedStreamIds_ = other.attachedStreamIds_.Clone(); + generated_ = other.generated_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TextHeader Clone() { + return new TextHeader(this); + } + + /// Field number for the "operation_type" field. + public const int OperationTypeFieldNumber = 1; + private readonly static global::LiveKit.Proto.DataStream.Types.OperationType OperationTypeDefaultValue = global::LiveKit.Proto.DataStream.Types.OperationType.Create; + + private global::LiveKit.Proto.DataStream.Types.OperationType operationType_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.DataStream.Types.OperationType OperationType { + get { if ((_hasBits0 & 1) != 0) { return operationType_; } else { return OperationTypeDefaultValue; } } + set { + _hasBits0 |= 1; + operationType_ = value; + } + } + /// Gets whether the "operation_type" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasOperationType { + get { return (_hasBits0 & 1) != 0; } + } + /// Clears the value of the "operation_type" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearOperationType() { + _hasBits0 &= ~1; + } + + /// Field number for the "version" field. + public const int VersionFieldNumber = 2; + private readonly static int VersionDefaultValue = 0; + + private int version_; + /// + /// Optional: Version for updates/edits + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int Version { + get { if ((_hasBits0 & 2) != 0) { return version_; } else { return VersionDefaultValue; } } + set { + _hasBits0 |= 2; + version_ = value; + } + } + /// Gets whether the "version" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasVersion { + get { return (_hasBits0 & 2) != 0; } + } + /// Clears the value of the "version" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearVersion() { + _hasBits0 &= ~2; + } + + /// Field number for the "reply_to_stream_id" field. + public const int ReplyToStreamIdFieldNumber = 3; + private readonly static string ReplyToStreamIdDefaultValue = ""; + + private string replyToStreamId_; + /// + /// Optional: Reply to specific message + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string ReplyToStreamId { + get { return replyToStreamId_ ?? ReplyToStreamIdDefaultValue; } + set { + replyToStreamId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + /// Gets whether the "reply_to_stream_id" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasReplyToStreamId { + get { return replyToStreamId_ != null; } + } + /// Clears the value of the "reply_to_stream_id" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearReplyToStreamId() { + replyToStreamId_ = null; + } + + /// Field number for the "attached_stream_ids" field. + public const int AttachedStreamIdsFieldNumber = 4; + private static readonly pb::FieldCodec _repeated_attachedStreamIds_codec + = pb::FieldCodec.ForString(34); + private readonly pbc::RepeatedField attachedStreamIds_ = new pbc::RepeatedField(); + /// + /// file attachments for text streams + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField AttachedStreamIds { + get { return attachedStreamIds_; } + } + + /// Field number for the "generated" field. + public const int GeneratedFieldNumber = 5; + private readonly static bool GeneratedDefaultValue = false; + + private bool generated_; + /// + /// true if the text has been generated by an agent from a participant's audio transcription + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Generated { + get { if ((_hasBits0 & 4) != 0) { return generated_; } else { return GeneratedDefaultValue; } } + set { + _hasBits0 |= 4; + generated_ = value; + } + } + /// Gets whether the "generated" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasGenerated { + get { return (_hasBits0 & 4) != 0; } + } + /// Clears the value of the "generated" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearGenerated() { + _hasBits0 &= ~4; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as TextHeader); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(TextHeader other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (OperationType != other.OperationType) return false; + if (Version != other.Version) return false; + if (ReplyToStreamId != other.ReplyToStreamId) return false; + if(!attachedStreamIds_.Equals(other.attachedStreamIds_)) return false; + if (Generated != other.Generated) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (HasOperationType) hash ^= OperationType.GetHashCode(); + if (HasVersion) hash ^= Version.GetHashCode(); + if (HasReplyToStreamId) hash ^= ReplyToStreamId.GetHashCode(); + hash ^= attachedStreamIds_.GetHashCode(); + if (HasGenerated) hash ^= Generated.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (HasOperationType) { + output.WriteRawTag(8); + output.WriteEnum((int) OperationType); + } + if (HasVersion) { + output.WriteRawTag(16); + output.WriteInt32(Version); + } + if (HasReplyToStreamId) { + output.WriteRawTag(26); + output.WriteString(ReplyToStreamId); + } + attachedStreamIds_.WriteTo(output, _repeated_attachedStreamIds_codec); + if (HasGenerated) { + output.WriteRawTag(40); + output.WriteBool(Generated); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (HasOperationType) { + output.WriteRawTag(8); + output.WriteEnum((int) OperationType); + } + if (HasVersion) { + output.WriteRawTag(16); + output.WriteInt32(Version); + } + if (HasReplyToStreamId) { + output.WriteRawTag(26); + output.WriteString(ReplyToStreamId); + } + attachedStreamIds_.WriteTo(ref output, _repeated_attachedStreamIds_codec); + if (HasGenerated) { + output.WriteRawTag(40); + output.WriteBool(Generated); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (HasOperationType) { + size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) OperationType); + } + if (HasVersion) { + size += 1 + pb::CodedOutputStream.ComputeInt32Size(Version); + } + if (HasReplyToStreamId) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(ReplyToStreamId); + } + size += attachedStreamIds_.CalculateSize(_repeated_attachedStreamIds_codec); + if (HasGenerated) { + size += 1 + 1; + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(TextHeader other) { + if (other == null) { + return; + } + if (other.HasOperationType) { + OperationType = other.OperationType; + } + if (other.HasVersion) { + Version = other.Version; + } + if (other.HasReplyToStreamId) { + ReplyToStreamId = other.ReplyToStreamId; + } + attachedStreamIds_.Add(other.attachedStreamIds_); + if (other.HasGenerated) { + Generated = other.Generated; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + OperationType = (global::LiveKit.Proto.DataStream.Types.OperationType) input.ReadEnum(); + break; + } + case 16: { + Version = input.ReadInt32(); + break; + } + case 26: { + ReplyToStreamId = input.ReadString(); + break; + } + case 34: { + attachedStreamIds_.AddEntriesFrom(input, _repeated_attachedStreamIds_codec); + break; + } + case 40: { + Generated = input.ReadBool(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + OperationType = (global::LiveKit.Proto.DataStream.Types.OperationType) input.ReadEnum(); + break; + } + case 16: { + Version = input.ReadInt32(); + break; + } + case 26: { + ReplyToStreamId = input.ReadString(); + break; + } + case 34: { + attachedStreamIds_.AddEntriesFrom(ref input, _repeated_attachedStreamIds_codec); + break; + } + case 40: { + Generated = input.ReadBool(); + break; + } + } + } + } + #endif + + } + + /// + /// header properties specific to byte or file streams + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class ByteHeader : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ByteHeader()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.DataStream.Descriptor.NestedTypes[1]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ByteHeader() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ByteHeader(ByteHeader other) : this() { + name_ = other.name_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ByteHeader Clone() { + return new ByteHeader(this); + } + + /// Field number for the "name" field. + public const int NameFieldNumber = 1; + private readonly static string NameDefaultValue = ""; + + private string name_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Name { + get { return name_ ?? NameDefaultValue; } + set { + name_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + /// Gets whether the "name" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasName { + get { return name_ != null; } + } + /// Clears the value of the "name" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearName() { + name_ = null; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as ByteHeader); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(ByteHeader other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Name != other.Name) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (HasName) hash ^= Name.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (HasName) { + output.WriteRawTag(10); + output.WriteString(Name); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (HasName) { + output.WriteRawTag(10); + output.WriteString(Name); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (HasName) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Name); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(ByteHeader other) { + if (other == null) { + return; + } + if (other.HasName) { + Name = other.Name; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + Name = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + Name = input.ReadString(); + break; + } + } + } + } + #endif + + } + + /// + /// main DataStream.Header that contains a oneof for specific headers + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class Header : pb::IMessage
+ #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser
_parser = new pb::MessageParser
(() => new Header()); + private pb::UnknownFieldSet _unknownFields; + private int _hasBits0; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser
Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.DataStream.Descriptor.NestedTypes[2]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public Header() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public Header(Header other) : this() { + _hasBits0 = other._hasBits0; + streamId_ = other.streamId_; + timestamp_ = other.timestamp_; + mimeType_ = other.mimeType_; + topic_ = other.topic_; + totalLength_ = other.totalLength_; + attributes_ = other.attributes_.Clone(); + switch (other.ContentHeaderCase) { + case ContentHeaderOneofCase.TextHeader: + TextHeader = other.TextHeader.Clone(); + break; + case ContentHeaderOneofCase.ByteHeader: + ByteHeader = other.ByteHeader.Clone(); + break; + } + + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public Header Clone() { + return new Header(this); + } + + /// Field number for the "stream_id" field. + public const int StreamIdFieldNumber = 1; + private readonly static string StreamIdDefaultValue = ""; + + private string streamId_; + /// + /// unique identifier for this data stream + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string StreamId { + get { return streamId_ ?? StreamIdDefaultValue; } + set { + streamId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + /// Gets whether the "stream_id" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasStreamId { + get { return streamId_ != null; } + } + /// Clears the value of the "stream_id" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearStreamId() { + streamId_ = null; + } + + /// Field number for the "timestamp" field. + public const int TimestampFieldNumber = 2; + private readonly static long TimestampDefaultValue = 0L; + + private long timestamp_; + /// + /// using int64 for Unix timestamp + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public long Timestamp { + get { if ((_hasBits0 & 1) != 0) { return timestamp_; } else { return TimestampDefaultValue; } } + set { + _hasBits0 |= 1; + timestamp_ = value; + } + } + /// Gets whether the "timestamp" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasTimestamp { + get { return (_hasBits0 & 1) != 0; } + } + /// Clears the value of the "timestamp" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearTimestamp() { + _hasBits0 &= ~1; + } + + /// Field number for the "mime_type" field. + public const int MimeTypeFieldNumber = 3; + private readonly static string MimeTypeDefaultValue = ""; + + private string mimeType_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string MimeType { + get { return mimeType_ ?? MimeTypeDefaultValue; } + set { + mimeType_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + /// Gets whether the "mime_type" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasMimeType { + get { return mimeType_ != null; } + } + /// Clears the value of the "mime_type" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearMimeType() { + mimeType_ = null; + } + + /// Field number for the "topic" field. + public const int TopicFieldNumber = 4; + private readonly static string TopicDefaultValue = ""; + + private string topic_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Topic { + get { return topic_ ?? TopicDefaultValue; } + set { + topic_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + /// Gets whether the "topic" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasTopic { + get { return topic_ != null; } + } + /// Clears the value of the "topic" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearTopic() { + topic_ = null; + } + + /// Field number for the "total_length" field. + public const int TotalLengthFieldNumber = 5; + private readonly static ulong TotalLengthDefaultValue = 0UL; + + private ulong totalLength_; + /// + /// only populated for finite streams, if it's a stream of unknown size this stays empty + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ulong TotalLength { + get { if ((_hasBits0 & 2) != 0) { return totalLength_; } else { return TotalLengthDefaultValue; } } + set { + _hasBits0 |= 2; + totalLength_ = value; + } + } + /// Gets whether the "total_length" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasTotalLength { + get { return (_hasBits0 & 2) != 0; } + } + /// Clears the value of the "total_length" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearTotalLength() { + _hasBits0 &= ~2; + } + + /// Field number for the "attributes" field. + public const int AttributesFieldNumber = 6; + private static readonly pbc::MapField.Codec _map_attributes_codec + = new pbc::MapField.Codec(pb::FieldCodec.ForString(10, ""), pb::FieldCodec.ForString(18, ""), 50); + private readonly pbc::MapField attributes_ = new pbc::MapField(); + /// + /// user defined attributes map that can carry additional info + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::MapField Attributes { + get { return attributes_; } + } + + /// Field number for the "text_header" field. + public const int TextHeaderFieldNumber = 7; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.DataStream.Types.TextHeader TextHeader { + get { return contentHeaderCase_ == ContentHeaderOneofCase.TextHeader ? (global::LiveKit.Proto.DataStream.Types.TextHeader) contentHeader_ : null; } + set { + contentHeader_ = value; + contentHeaderCase_ = value == null ? ContentHeaderOneofCase.None : ContentHeaderOneofCase.TextHeader; + } + } + + /// Field number for the "byte_header" field. + public const int ByteHeaderFieldNumber = 8; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.DataStream.Types.ByteHeader ByteHeader { + get { return contentHeaderCase_ == ContentHeaderOneofCase.ByteHeader ? (global::LiveKit.Proto.DataStream.Types.ByteHeader) contentHeader_ : null; } + set { + contentHeader_ = value; + contentHeaderCase_ = value == null ? ContentHeaderOneofCase.None : ContentHeaderOneofCase.ByteHeader; + } + } + + private object contentHeader_; + /// Enum of possible cases for the "content_header" oneof. + public enum ContentHeaderOneofCase { + None = 0, + TextHeader = 7, + ByteHeader = 8, + } + private ContentHeaderOneofCase contentHeaderCase_ = ContentHeaderOneofCase.None; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ContentHeaderOneofCase ContentHeaderCase { + get { return contentHeaderCase_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearContentHeader() { + contentHeaderCase_ = ContentHeaderOneofCase.None; + contentHeader_ = null; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as Header); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(Header other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (StreamId != other.StreamId) return false; + if (Timestamp != other.Timestamp) return false; + if (MimeType != other.MimeType) return false; + if (Topic != other.Topic) return false; + if (TotalLength != other.TotalLength) return false; + if (!Attributes.Equals(other.Attributes)) return false; + if (!object.Equals(TextHeader, other.TextHeader)) return false; + if (!object.Equals(ByteHeader, other.ByteHeader)) return false; + if (ContentHeaderCase != other.ContentHeaderCase) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (HasStreamId) hash ^= StreamId.GetHashCode(); + if (HasTimestamp) hash ^= Timestamp.GetHashCode(); + if (HasMimeType) hash ^= MimeType.GetHashCode(); + if (HasTopic) hash ^= Topic.GetHashCode(); + if (HasTotalLength) hash ^= TotalLength.GetHashCode(); + hash ^= Attributes.GetHashCode(); + if (contentHeaderCase_ == ContentHeaderOneofCase.TextHeader) hash ^= TextHeader.GetHashCode(); + if (contentHeaderCase_ == ContentHeaderOneofCase.ByteHeader) hash ^= ByteHeader.GetHashCode(); + hash ^= (int) contentHeaderCase_; + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (HasStreamId) { + output.WriteRawTag(10); + output.WriteString(StreamId); + } + if (HasTimestamp) { + output.WriteRawTag(16); + output.WriteInt64(Timestamp); + } + if (HasMimeType) { + output.WriteRawTag(26); + output.WriteString(MimeType); + } + if (HasTopic) { + output.WriteRawTag(34); + output.WriteString(Topic); + } + if (HasTotalLength) { + output.WriteRawTag(40); + output.WriteUInt64(TotalLength); + } + attributes_.WriteTo(output, _map_attributes_codec); + if (contentHeaderCase_ == ContentHeaderOneofCase.TextHeader) { + output.WriteRawTag(58); + output.WriteMessage(TextHeader); + } + if (contentHeaderCase_ == ContentHeaderOneofCase.ByteHeader) { + output.WriteRawTag(66); + output.WriteMessage(ByteHeader); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (HasStreamId) { + output.WriteRawTag(10); + output.WriteString(StreamId); + } + if (HasTimestamp) { + output.WriteRawTag(16); + output.WriteInt64(Timestamp); + } + if (HasMimeType) { + output.WriteRawTag(26); + output.WriteString(MimeType); + } + if (HasTopic) { + output.WriteRawTag(34); + output.WriteString(Topic); + } + if (HasTotalLength) { + output.WriteRawTag(40); + output.WriteUInt64(TotalLength); + } + attributes_.WriteTo(ref output, _map_attributes_codec); + if (contentHeaderCase_ == ContentHeaderOneofCase.TextHeader) { + output.WriteRawTag(58); + output.WriteMessage(TextHeader); + } + if (contentHeaderCase_ == ContentHeaderOneofCase.ByteHeader) { + output.WriteRawTag(66); + output.WriteMessage(ByteHeader); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (HasStreamId) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(StreamId); + } + if (HasTimestamp) { + size += 1 + pb::CodedOutputStream.ComputeInt64Size(Timestamp); + } + if (HasMimeType) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(MimeType); + } + if (HasTopic) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Topic); + } + if (HasTotalLength) { + size += 1 + pb::CodedOutputStream.ComputeUInt64Size(TotalLength); + } + size += attributes_.CalculateSize(_map_attributes_codec); + if (contentHeaderCase_ == ContentHeaderOneofCase.TextHeader) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(TextHeader); + } + if (contentHeaderCase_ == ContentHeaderOneofCase.ByteHeader) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(ByteHeader); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(Header other) { + if (other == null) { + return; + } + if (other.HasStreamId) { + StreamId = other.StreamId; + } + if (other.HasTimestamp) { + Timestamp = other.Timestamp; + } + if (other.HasMimeType) { + MimeType = other.MimeType; + } + if (other.HasTopic) { + Topic = other.Topic; + } + if (other.HasTotalLength) { + TotalLength = other.TotalLength; + } + attributes_.MergeFrom(other.attributes_); + switch (other.ContentHeaderCase) { + case ContentHeaderOneofCase.TextHeader: + if (TextHeader == null) { + TextHeader = new global::LiveKit.Proto.DataStream.Types.TextHeader(); + } + TextHeader.MergeFrom(other.TextHeader); + break; + case ContentHeaderOneofCase.ByteHeader: + if (ByteHeader == null) { + ByteHeader = new global::LiveKit.Proto.DataStream.Types.ByteHeader(); + } + ByteHeader.MergeFrom(other.ByteHeader); + break; + } + + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + StreamId = input.ReadString(); + break; + } + case 16: { + Timestamp = input.ReadInt64(); + break; + } + case 26: { + MimeType = input.ReadString(); + break; + } + case 34: { + Topic = input.ReadString(); + break; + } + case 40: { + TotalLength = input.ReadUInt64(); + break; + } + case 50: { + attributes_.AddEntriesFrom(input, _map_attributes_codec); + break; + } + case 58: { + global::LiveKit.Proto.DataStream.Types.TextHeader subBuilder = new global::LiveKit.Proto.DataStream.Types.TextHeader(); + if (contentHeaderCase_ == ContentHeaderOneofCase.TextHeader) { + subBuilder.MergeFrom(TextHeader); + } + input.ReadMessage(subBuilder); + TextHeader = subBuilder; + break; + } + case 66: { + global::LiveKit.Proto.DataStream.Types.ByteHeader subBuilder = new global::LiveKit.Proto.DataStream.Types.ByteHeader(); + if (contentHeaderCase_ == ContentHeaderOneofCase.ByteHeader) { + subBuilder.MergeFrom(ByteHeader); + } + input.ReadMessage(subBuilder); + ByteHeader = subBuilder; + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + StreamId = input.ReadString(); + break; + } + case 16: { + Timestamp = input.ReadInt64(); + break; + } + case 26: { + MimeType = input.ReadString(); + break; + } + case 34: { + Topic = input.ReadString(); + break; + } + case 40: { + TotalLength = input.ReadUInt64(); + break; + } + case 50: { + attributes_.AddEntriesFrom(ref input, _map_attributes_codec); + break; + } + case 58: { + global::LiveKit.Proto.DataStream.Types.TextHeader subBuilder = new global::LiveKit.Proto.DataStream.Types.TextHeader(); + if (contentHeaderCase_ == ContentHeaderOneofCase.TextHeader) { + subBuilder.MergeFrom(TextHeader); + } + input.ReadMessage(subBuilder); + TextHeader = subBuilder; + break; + } + case 66: { + global::LiveKit.Proto.DataStream.Types.ByteHeader subBuilder = new global::LiveKit.Proto.DataStream.Types.ByteHeader(); + if (contentHeaderCase_ == ContentHeaderOneofCase.ByteHeader) { + subBuilder.MergeFrom(ByteHeader); + } + input.ReadMessage(subBuilder); + ByteHeader = subBuilder; + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class Chunk : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new Chunk()); + private pb::UnknownFieldSet _unknownFields; + private int _hasBits0; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.DataStream.Descriptor.NestedTypes[3]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public Chunk() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public Chunk(Chunk other) : this() { + _hasBits0 = other._hasBits0; + streamId_ = other.streamId_; + chunkIndex_ = other.chunkIndex_; + content_ = other.content_; + version_ = other.version_; + iv_ = other.iv_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public Chunk Clone() { + return new Chunk(this); + } + + /// Field number for the "stream_id" field. + public const int StreamIdFieldNumber = 1; + private readonly static string StreamIdDefaultValue = ""; + + private string streamId_; + /// + /// unique identifier for this data stream to map it to the correct header + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string StreamId { + get { return streamId_ ?? StreamIdDefaultValue; } + set { + streamId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + /// Gets whether the "stream_id" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasStreamId { + get { return streamId_ != null; } + } + /// Clears the value of the "stream_id" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearStreamId() { + streamId_ = null; + } + + /// Field number for the "chunk_index" field. + public const int ChunkIndexFieldNumber = 2; + private readonly static ulong ChunkIndexDefaultValue = 0UL; + + private ulong chunkIndex_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ulong ChunkIndex { + get { if ((_hasBits0 & 1) != 0) { return chunkIndex_; } else { return ChunkIndexDefaultValue; } } + set { + _hasBits0 |= 1; + chunkIndex_ = value; + } + } + /// Gets whether the "chunk_index" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasChunkIndex { + get { return (_hasBits0 & 1) != 0; } + } + /// Clears the value of the "chunk_index" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearChunkIndex() { + _hasBits0 &= ~1; + } + + /// Field number for the "content" field. + public const int ContentFieldNumber = 3; + private readonly static pb::ByteString ContentDefaultValue = pb::ByteString.Empty; + + private pb::ByteString content_; + /// + /// content as binary (bytes) + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pb::ByteString Content { + get { return content_ ?? ContentDefaultValue; } + set { + content_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + /// Gets whether the "content" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasContent { + get { return content_ != null; } + } + /// Clears the value of the "content" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearContent() { + content_ = null; + } + + /// Field number for the "version" field. + public const int VersionFieldNumber = 4; + private readonly static int VersionDefaultValue = 0; + + private int version_; + /// + /// a version indicating that this chunk_index has been retroactively modified and the original one needs to be replaced + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int Version { + get { if ((_hasBits0 & 2) != 0) { return version_; } else { return VersionDefaultValue; } } + set { + _hasBits0 |= 2; + version_ = value; + } + } + /// Gets whether the "version" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasVersion { + get { return (_hasBits0 & 2) != 0; } + } + /// Clears the value of the "version" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearVersion() { + _hasBits0 &= ~2; + } + + /// Field number for the "iv" field. + public const int IvFieldNumber = 5; + private readonly static pb::ByteString IvDefaultValue = pb::ByteString.Empty; + + private pb::ByteString iv_; + /// + /// optional, initialization vector for AES-GCM encryption + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pb::ByteString Iv { + get { return iv_ ?? IvDefaultValue; } + set { + iv_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + /// Gets whether the "iv" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasIv { + get { return iv_ != null; } + } + /// Clears the value of the "iv" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearIv() { + iv_ = null; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as Chunk); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(Chunk other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (StreamId != other.StreamId) return false; + if (ChunkIndex != other.ChunkIndex) return false; + if (Content != other.Content) return false; + if (Version != other.Version) return false; + if (Iv != other.Iv) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (HasStreamId) hash ^= StreamId.GetHashCode(); + if (HasChunkIndex) hash ^= ChunkIndex.GetHashCode(); + if (HasContent) hash ^= Content.GetHashCode(); + if (HasVersion) hash ^= Version.GetHashCode(); + if (HasIv) hash ^= Iv.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (HasStreamId) { + output.WriteRawTag(10); + output.WriteString(StreamId); + } + if (HasChunkIndex) { + output.WriteRawTag(16); + output.WriteUInt64(ChunkIndex); + } + if (HasContent) { + output.WriteRawTag(26); + output.WriteBytes(Content); + } + if (HasVersion) { + output.WriteRawTag(32); + output.WriteInt32(Version); + } + if (HasIv) { + output.WriteRawTag(42); + output.WriteBytes(Iv); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (HasStreamId) { + output.WriteRawTag(10); + output.WriteString(StreamId); + } + if (HasChunkIndex) { + output.WriteRawTag(16); + output.WriteUInt64(ChunkIndex); + } + if (HasContent) { + output.WriteRawTag(26); + output.WriteBytes(Content); + } + if (HasVersion) { + output.WriteRawTag(32); + output.WriteInt32(Version); + } + if (HasIv) { + output.WriteRawTag(42); + output.WriteBytes(Iv); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (HasStreamId) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(StreamId); + } + if (HasChunkIndex) { + size += 1 + pb::CodedOutputStream.ComputeUInt64Size(ChunkIndex); + } + if (HasContent) { + size += 1 + pb::CodedOutputStream.ComputeBytesSize(Content); + } + if (HasVersion) { + size += 1 + pb::CodedOutputStream.ComputeInt32Size(Version); + } + if (HasIv) { + size += 1 + pb::CodedOutputStream.ComputeBytesSize(Iv); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(Chunk other) { + if (other == null) { + return; + } + if (other.HasStreamId) { + StreamId = other.StreamId; + } + if (other.HasChunkIndex) { + ChunkIndex = other.ChunkIndex; + } + if (other.HasContent) { + Content = other.Content; + } + if (other.HasVersion) { + Version = other.Version; + } + if (other.HasIv) { + Iv = other.Iv; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + StreamId = input.ReadString(); + break; + } + case 16: { + ChunkIndex = input.ReadUInt64(); + break; + } + case 26: { + Content = input.ReadBytes(); + break; + } + case 32: { + Version = input.ReadInt32(); + break; + } + case 42: { + Iv = input.ReadBytes(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + StreamId = input.ReadString(); + break; + } + case 16: { + ChunkIndex = input.ReadUInt64(); + break; + } + case 26: { + Content = input.ReadBytes(); + break; + } + case 32: { + Version = input.ReadInt32(); + break; + } + case 42: { + Iv = input.ReadBytes(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class Trailer : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new Trailer()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.DataStream.Descriptor.NestedTypes[4]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public Trailer() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public Trailer(Trailer other) : this() { + streamId_ = other.streamId_; + reason_ = other.reason_; + attributes_ = other.attributes_.Clone(); + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public Trailer Clone() { + return new Trailer(this); + } + + /// Field number for the "stream_id" field. + public const int StreamIdFieldNumber = 1; + private readonly static string StreamIdDefaultValue = ""; + + private string streamId_; + /// + /// unique identifier for this data stream + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string StreamId { + get { return streamId_ ?? StreamIdDefaultValue; } + set { + streamId_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + /// Gets whether the "stream_id" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasStreamId { + get { return streamId_ != null; } + } + /// Clears the value of the "stream_id" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearStreamId() { + streamId_ = null; + } + + /// Field number for the "reason" field. + public const int ReasonFieldNumber = 2; + private readonly static string ReasonDefaultValue = ""; + + private string reason_; + /// + /// reason why the stream was closed (could contain "error" / "interrupted" / empty for expected end) + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Reason { + get { return reason_ ?? ReasonDefaultValue; } + set { + reason_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + /// Gets whether the "reason" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasReason { + get { return reason_ != null; } + } + /// Clears the value of the "reason" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearReason() { + reason_ = null; + } + + /// Field number for the "attributes" field. + public const int AttributesFieldNumber = 3; + private static readonly pbc::MapField.Codec _map_attributes_codec + = new pbc::MapField.Codec(pb::FieldCodec.ForString(10, ""), pb::FieldCodec.ForString(18, ""), 26); + private readonly pbc::MapField attributes_ = new pbc::MapField(); + /// + /// finalizing updates for the stream, can also include additional insights for errors or endTime for transcription + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::MapField Attributes { + get { return attributes_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as Trailer); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(Trailer other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (StreamId != other.StreamId) return false; + if (Reason != other.Reason) return false; + if (!Attributes.Equals(other.Attributes)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (HasStreamId) hash ^= StreamId.GetHashCode(); + if (HasReason) hash ^= Reason.GetHashCode(); + hash ^= Attributes.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (HasStreamId) { + output.WriteRawTag(10); + output.WriteString(StreamId); + } + if (HasReason) { + output.WriteRawTag(18); + output.WriteString(Reason); + } + attributes_.WriteTo(output, _map_attributes_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (HasStreamId) { + output.WriteRawTag(10); + output.WriteString(StreamId); + } + if (HasReason) { + output.WriteRawTag(18); + output.WriteString(Reason); + } + attributes_.WriteTo(ref output, _map_attributes_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (HasStreamId) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(StreamId); + } + if (HasReason) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Reason); + } + size += attributes_.CalculateSize(_map_attributes_codec); + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(Trailer other) { + if (other == null) { + return; + } + if (other.HasStreamId) { + StreamId = other.StreamId; + } + if (other.HasReason) { + Reason = other.Reason; + } + attributes_.MergeFrom(other.attributes_); + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + StreamId = input.ReadString(); + break; + } + case 18: { + Reason = input.ReadString(); + break; + } + case 26: { + attributes_.AddEntriesFrom(input, _map_attributes_codec); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + StreamId = input.ReadString(); + break; + } + case 18: { + Reason = input.ReadString(); + break; + } + case 26: { + attributes_.AddEntriesFrom(ref input, _map_attributes_codec); + break; + } + } + } + } + #endif + + } + + } + #endregion + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class DataStreamHeaderReceived : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new DataStreamHeaderReceived()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.RoomReflection.Descriptor.MessageTypes[85]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public DataStreamHeaderReceived() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public DataStreamHeaderReceived(DataStreamHeaderReceived other) : this() { + participantIdentity_ = other.participantIdentity_; + header_ = other.header_ != null ? other.header_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public DataStreamHeaderReceived Clone() { + return new DataStreamHeaderReceived(this); + } + + /// Field number for the "participant_identity" field. + public const int ParticipantIdentityFieldNumber = 1; + private readonly static string ParticipantIdentityDefaultValue = ""; + + private string participantIdentity_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string ParticipantIdentity { + get { return participantIdentity_ ?? ParticipantIdentityDefaultValue; } + set { + participantIdentity_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + /// Gets whether the "participant_identity" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasParticipantIdentity { + get { return participantIdentity_ != null; } + } + /// Clears the value of the "participant_identity" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearParticipantIdentity() { + participantIdentity_ = null; + } + + /// Field number for the "header" field. + public const int HeaderFieldNumber = 2; + private global::LiveKit.Proto.DataStream.Types.Header header_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.DataStream.Types.Header Header { + get { return header_; } + set { + header_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as DataStreamHeaderReceived); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(DataStreamHeaderReceived other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (ParticipantIdentity != other.ParticipantIdentity) return false; + if (!object.Equals(Header, other.Header)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (HasParticipantIdentity) hash ^= ParticipantIdentity.GetHashCode(); + if (header_ != null) hash ^= Header.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (HasParticipantIdentity) { + output.WriteRawTag(10); + output.WriteString(ParticipantIdentity); + } + if (header_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Header); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (HasParticipantIdentity) { + output.WriteRawTag(10); + output.WriteString(ParticipantIdentity); + } + if (header_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Header); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (HasParticipantIdentity) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(ParticipantIdentity); + } + if (header_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Header); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(DataStreamHeaderReceived other) { + if (other == null) { + return; + } + if (other.HasParticipantIdentity) { + ParticipantIdentity = other.ParticipantIdentity; + } + if (other.header_ != null) { + if (header_ == null) { + Header = new global::LiveKit.Proto.DataStream.Types.Header(); + } + Header.MergeFrom(other.Header); + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + ParticipantIdentity = input.ReadString(); + break; + } + case 18: { + if (header_ == null) { + Header = new global::LiveKit.Proto.DataStream.Types.Header(); + } + input.ReadMessage(Header); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + ParticipantIdentity = input.ReadString(); + break; + } + case 18: { + if (header_ == null) { + Header = new global::LiveKit.Proto.DataStream.Types.Header(); + } + input.ReadMessage(Header); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class DataStreamChunkReceived : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new DataStreamChunkReceived()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.RoomReflection.Descriptor.MessageTypes[86]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public DataStreamChunkReceived() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public DataStreamChunkReceived(DataStreamChunkReceived other) : this() { + participantIdentity_ = other.participantIdentity_; + chunk_ = other.chunk_ != null ? other.chunk_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public DataStreamChunkReceived Clone() { + return new DataStreamChunkReceived(this); + } + + /// Field number for the "participant_identity" field. + public const int ParticipantIdentityFieldNumber = 1; + private readonly static string ParticipantIdentityDefaultValue = ""; + + private string participantIdentity_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string ParticipantIdentity { + get { return participantIdentity_ ?? ParticipantIdentityDefaultValue; } + set { + participantIdentity_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + /// Gets whether the "participant_identity" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasParticipantIdentity { + get { return participantIdentity_ != null; } + } + /// Clears the value of the "participant_identity" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearParticipantIdentity() { + participantIdentity_ = null; + } + + /// Field number for the "chunk" field. + public const int ChunkFieldNumber = 2; + private global::LiveKit.Proto.DataStream.Types.Chunk chunk_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.DataStream.Types.Chunk Chunk { + get { return chunk_; } + set { + chunk_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as DataStreamChunkReceived); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(DataStreamChunkReceived other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (ParticipantIdentity != other.ParticipantIdentity) return false; + if (!object.Equals(Chunk, other.Chunk)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (HasParticipantIdentity) hash ^= ParticipantIdentity.GetHashCode(); + if (chunk_ != null) hash ^= Chunk.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (HasParticipantIdentity) { + output.WriteRawTag(10); + output.WriteString(ParticipantIdentity); + } + if (chunk_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Chunk); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (HasParticipantIdentity) { + output.WriteRawTag(10); + output.WriteString(ParticipantIdentity); + } + if (chunk_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Chunk); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (HasParticipantIdentity) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(ParticipantIdentity); + } + if (chunk_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Chunk); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(DataStreamChunkReceived other) { + if (other == null) { + return; + } + if (other.HasParticipantIdentity) { + ParticipantIdentity = other.ParticipantIdentity; + } + if (other.chunk_ != null) { + if (chunk_ == null) { + Chunk = new global::LiveKit.Proto.DataStream.Types.Chunk(); + } + Chunk.MergeFrom(other.Chunk); + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + ParticipantIdentity = input.ReadString(); + break; + } + case 18: { + if (chunk_ == null) { + Chunk = new global::LiveKit.Proto.DataStream.Types.Chunk(); + } + input.ReadMessage(Chunk); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + ParticipantIdentity = input.ReadString(); + break; + } + case 18: { + if (chunk_ == null) { + Chunk = new global::LiveKit.Proto.DataStream.Types.Chunk(); + } + input.ReadMessage(Chunk); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class DataStreamTrailerReceived : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new DataStreamTrailerReceived()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.RoomReflection.Descriptor.MessageTypes[87]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public DataStreamTrailerReceived() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public DataStreamTrailerReceived(DataStreamTrailerReceived other) : this() { + participantIdentity_ = other.participantIdentity_; + trailer_ = other.trailer_ != null ? other.trailer_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public DataStreamTrailerReceived Clone() { + return new DataStreamTrailerReceived(this); + } + + /// Field number for the "participant_identity" field. + public const int ParticipantIdentityFieldNumber = 1; + private readonly static string ParticipantIdentityDefaultValue = ""; + + private string participantIdentity_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string ParticipantIdentity { + get { return participantIdentity_ ?? ParticipantIdentityDefaultValue; } + set { + participantIdentity_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + /// Gets whether the "participant_identity" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasParticipantIdentity { + get { return participantIdentity_ != null; } + } + /// Clears the value of the "participant_identity" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearParticipantIdentity() { + participantIdentity_ = null; + } + + /// Field number for the "trailer" field. + public const int TrailerFieldNumber = 2; + private global::LiveKit.Proto.DataStream.Types.Trailer trailer_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.DataStream.Types.Trailer Trailer { + get { return trailer_; } + set { + trailer_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as DataStreamTrailerReceived); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(DataStreamTrailerReceived other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (ParticipantIdentity != other.ParticipantIdentity) return false; + if (!object.Equals(Trailer, other.Trailer)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (HasParticipantIdentity) hash ^= ParticipantIdentity.GetHashCode(); + if (trailer_ != null) hash ^= Trailer.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (HasParticipantIdentity) { + output.WriteRawTag(10); + output.WriteString(ParticipantIdentity); + } + if (trailer_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Trailer); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (HasParticipantIdentity) { + output.WriteRawTag(10); + output.WriteString(ParticipantIdentity); + } + if (trailer_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Trailer); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (HasParticipantIdentity) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(ParticipantIdentity); + } + if (trailer_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Trailer); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(DataStreamTrailerReceived other) { + if (other == null) { + return; + } + if (other.HasParticipantIdentity) { + ParticipantIdentity = other.ParticipantIdentity; + } + if (other.trailer_ != null) { + if (trailer_ == null) { + Trailer = new global::LiveKit.Proto.DataStream.Types.Trailer(); + } + Trailer.MergeFrom(other.Trailer); + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + ParticipantIdentity = input.ReadString(); + break; + } + case 18: { + if (trailer_ == null) { + Trailer = new global::LiveKit.Proto.DataStream.Types.Trailer(); + } + input.ReadMessage(Trailer); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + ParticipantIdentity = input.ReadString(); + break; + } + case 18: { + if (trailer_ == null) { + Trailer = new global::LiveKit.Proto.DataStream.Types.Trailer(); + } + input.ReadMessage(Trailer); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class SendStreamHeaderRequest : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new SendStreamHeaderRequest()); + private pb::UnknownFieldSet _unknownFields; + private int _hasBits0; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.RoomReflection.Descriptor.MessageTypes[88]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SendStreamHeaderRequest() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SendStreamHeaderRequest(SendStreamHeaderRequest other) : this() { + _hasBits0 = other._hasBits0; + localParticipantHandle_ = other.localParticipantHandle_; + header_ = other.header_ != null ? other.header_.Clone() : null; + destinationIdentities_ = other.destinationIdentities_.Clone(); + senderIdentity_ = other.senderIdentity_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SendStreamHeaderRequest Clone() { + return new SendStreamHeaderRequest(this); + } + + /// Field number for the "local_participant_handle" field. + public const int LocalParticipantHandleFieldNumber = 1; + private readonly static ulong LocalParticipantHandleDefaultValue = 0UL; + + private ulong localParticipantHandle_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ulong LocalParticipantHandle { + get { if ((_hasBits0 & 1) != 0) { return localParticipantHandle_; } else { return LocalParticipantHandleDefaultValue; } } + set { + _hasBits0 |= 1; + localParticipantHandle_ = value; + } + } + /// Gets whether the "local_participant_handle" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasLocalParticipantHandle { + get { return (_hasBits0 & 1) != 0; } + } + /// Clears the value of the "local_participant_handle" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearLocalParticipantHandle() { + _hasBits0 &= ~1; + } + + /// Field number for the "header" field. + public const int HeaderFieldNumber = 2; + private global::LiveKit.Proto.DataStream.Types.Header header_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.DataStream.Types.Header Header { + get { return header_; } + set { + header_ = value; + } + } + + /// Field number for the "destination_identities" field. + public const int DestinationIdentitiesFieldNumber = 3; + private static readonly pb::FieldCodec _repeated_destinationIdentities_codec + = pb::FieldCodec.ForString(26); + private readonly pbc::RepeatedField destinationIdentities_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField DestinationIdentities { + get { return destinationIdentities_; } + } + + /// Field number for the "sender_identity" field. + public const int SenderIdentityFieldNumber = 4; + private readonly static string SenderIdentityDefaultValue = ""; + + private string senderIdentity_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string SenderIdentity { + get { return senderIdentity_ ?? SenderIdentityDefaultValue; } + set { + senderIdentity_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + /// Gets whether the "sender_identity" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasSenderIdentity { + get { return senderIdentity_ != null; } + } + /// Clears the value of the "sender_identity" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearSenderIdentity() { + senderIdentity_ = null; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as SendStreamHeaderRequest); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(SendStreamHeaderRequest other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (LocalParticipantHandle != other.LocalParticipantHandle) return false; + if (!object.Equals(Header, other.Header)) return false; + if(!destinationIdentities_.Equals(other.destinationIdentities_)) return false; + if (SenderIdentity != other.SenderIdentity) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (HasLocalParticipantHandle) hash ^= LocalParticipantHandle.GetHashCode(); + if (header_ != null) hash ^= Header.GetHashCode(); + hash ^= destinationIdentities_.GetHashCode(); + if (HasSenderIdentity) hash ^= SenderIdentity.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (HasLocalParticipantHandle) { + output.WriteRawTag(8); + output.WriteUInt64(LocalParticipantHandle); + } + if (header_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Header); + } + destinationIdentities_.WriteTo(output, _repeated_destinationIdentities_codec); + if (HasSenderIdentity) { + output.WriteRawTag(34); + output.WriteString(SenderIdentity); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (HasLocalParticipantHandle) { + output.WriteRawTag(8); + output.WriteUInt64(LocalParticipantHandle); + } + if (header_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Header); + } + destinationIdentities_.WriteTo(ref output, _repeated_destinationIdentities_codec); + if (HasSenderIdentity) { + output.WriteRawTag(34); + output.WriteString(SenderIdentity); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (HasLocalParticipantHandle) { + size += 1 + pb::CodedOutputStream.ComputeUInt64Size(LocalParticipantHandle); + } + if (header_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Header); + } + size += destinationIdentities_.CalculateSize(_repeated_destinationIdentities_codec); + if (HasSenderIdentity) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(SenderIdentity); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(SendStreamHeaderRequest other) { + if (other == null) { + return; + } + if (other.HasLocalParticipantHandle) { + LocalParticipantHandle = other.LocalParticipantHandle; + } + if (other.header_ != null) { + if (header_ == null) { + Header = new global::LiveKit.Proto.DataStream.Types.Header(); + } + Header.MergeFrom(other.Header); + } + destinationIdentities_.Add(other.destinationIdentities_); + if (other.HasSenderIdentity) { + SenderIdentity = other.SenderIdentity; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + LocalParticipantHandle = input.ReadUInt64(); + break; + } + case 18: { + if (header_ == null) { + Header = new global::LiveKit.Proto.DataStream.Types.Header(); + } + input.ReadMessage(Header); + break; + } + case 26: { + destinationIdentities_.AddEntriesFrom(input, _repeated_destinationIdentities_codec); + break; + } + case 34: { + SenderIdentity = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + LocalParticipantHandle = input.ReadUInt64(); + break; + } + case 18: { + if (header_ == null) { + Header = new global::LiveKit.Proto.DataStream.Types.Header(); + } + input.ReadMessage(Header); + break; + } + case 26: { + destinationIdentities_.AddEntriesFrom(ref input, _repeated_destinationIdentities_codec); + break; + } + case 34: { + SenderIdentity = input.ReadString(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class SendStreamChunkRequest : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new SendStreamChunkRequest()); + private pb::UnknownFieldSet _unknownFields; + private int _hasBits0; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.RoomReflection.Descriptor.MessageTypes[89]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SendStreamChunkRequest() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SendStreamChunkRequest(SendStreamChunkRequest other) : this() { + _hasBits0 = other._hasBits0; + localParticipantHandle_ = other.localParticipantHandle_; + chunk_ = other.chunk_ != null ? other.chunk_.Clone() : null; + destinationIdentities_ = other.destinationIdentities_.Clone(); + senderIdentity_ = other.senderIdentity_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SendStreamChunkRequest Clone() { + return new SendStreamChunkRequest(this); + } + + /// Field number for the "local_participant_handle" field. + public const int LocalParticipantHandleFieldNumber = 1; + private readonly static ulong LocalParticipantHandleDefaultValue = 0UL; + + private ulong localParticipantHandle_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ulong LocalParticipantHandle { + get { if ((_hasBits0 & 1) != 0) { return localParticipantHandle_; } else { return LocalParticipantHandleDefaultValue; } } + set { + _hasBits0 |= 1; + localParticipantHandle_ = value; + } + } + /// Gets whether the "local_participant_handle" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasLocalParticipantHandle { + get { return (_hasBits0 & 1) != 0; } + } + /// Clears the value of the "local_participant_handle" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearLocalParticipantHandle() { + _hasBits0 &= ~1; + } + + /// Field number for the "chunk" field. + public const int ChunkFieldNumber = 2; + private global::LiveKit.Proto.DataStream.Types.Chunk chunk_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.DataStream.Types.Chunk Chunk { + get { return chunk_; } + set { + chunk_ = value; + } + } + + /// Field number for the "destination_identities" field. + public const int DestinationIdentitiesFieldNumber = 3; + private static readonly pb::FieldCodec _repeated_destinationIdentities_codec + = pb::FieldCodec.ForString(26); + private readonly pbc::RepeatedField destinationIdentities_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField DestinationIdentities { + get { return destinationIdentities_; } + } + + /// Field number for the "sender_identity" field. + public const int SenderIdentityFieldNumber = 4; + private readonly static string SenderIdentityDefaultValue = ""; + + private string senderIdentity_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string SenderIdentity { + get { return senderIdentity_ ?? SenderIdentityDefaultValue; } + set { + senderIdentity_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + /// Gets whether the "sender_identity" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasSenderIdentity { + get { return senderIdentity_ != null; } + } + /// Clears the value of the "sender_identity" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearSenderIdentity() { + senderIdentity_ = null; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as SendStreamChunkRequest); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(SendStreamChunkRequest other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (LocalParticipantHandle != other.LocalParticipantHandle) return false; + if (!object.Equals(Chunk, other.Chunk)) return false; + if(!destinationIdentities_.Equals(other.destinationIdentities_)) return false; + if (SenderIdentity != other.SenderIdentity) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (HasLocalParticipantHandle) hash ^= LocalParticipantHandle.GetHashCode(); + if (chunk_ != null) hash ^= Chunk.GetHashCode(); + hash ^= destinationIdentities_.GetHashCode(); + if (HasSenderIdentity) hash ^= SenderIdentity.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (HasLocalParticipantHandle) { + output.WriteRawTag(8); + output.WriteUInt64(LocalParticipantHandle); + } + if (chunk_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Chunk); + } + destinationIdentities_.WriteTo(output, _repeated_destinationIdentities_codec); + if (HasSenderIdentity) { + output.WriteRawTag(34); + output.WriteString(SenderIdentity); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (HasLocalParticipantHandle) { + output.WriteRawTag(8); + output.WriteUInt64(LocalParticipantHandle); + } + if (chunk_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Chunk); + } + destinationIdentities_.WriteTo(ref output, _repeated_destinationIdentities_codec); + if (HasSenderIdentity) { + output.WriteRawTag(34); + output.WriteString(SenderIdentity); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (HasLocalParticipantHandle) { + size += 1 + pb::CodedOutputStream.ComputeUInt64Size(LocalParticipantHandle); + } + if (chunk_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Chunk); + } + size += destinationIdentities_.CalculateSize(_repeated_destinationIdentities_codec); + if (HasSenderIdentity) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(SenderIdentity); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(SendStreamChunkRequest other) { + if (other == null) { + return; + } + if (other.HasLocalParticipantHandle) { + LocalParticipantHandle = other.LocalParticipantHandle; + } + if (other.chunk_ != null) { + if (chunk_ == null) { + Chunk = new global::LiveKit.Proto.DataStream.Types.Chunk(); + } + Chunk.MergeFrom(other.Chunk); + } + destinationIdentities_.Add(other.destinationIdentities_); + if (other.HasSenderIdentity) { + SenderIdentity = other.SenderIdentity; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + LocalParticipantHandle = input.ReadUInt64(); + break; + } + case 18: { + if (chunk_ == null) { + Chunk = new global::LiveKit.Proto.DataStream.Types.Chunk(); + } + input.ReadMessage(Chunk); + break; + } + case 26: { + destinationIdentities_.AddEntriesFrom(input, _repeated_destinationIdentities_codec); + break; + } + case 34: { + SenderIdentity = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + LocalParticipantHandle = input.ReadUInt64(); + break; + } + case 18: { + if (chunk_ == null) { + Chunk = new global::LiveKit.Proto.DataStream.Types.Chunk(); + } + input.ReadMessage(Chunk); + break; + } + case 26: { + destinationIdentities_.AddEntriesFrom(ref input, _repeated_destinationIdentities_codec); + break; + } + case 34: { + SenderIdentity = input.ReadString(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class SendStreamTrailerRequest : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new SendStreamTrailerRequest()); + private pb::UnknownFieldSet _unknownFields; + private int _hasBits0; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.RoomReflection.Descriptor.MessageTypes[90]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SendStreamTrailerRequest() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SendStreamTrailerRequest(SendStreamTrailerRequest other) : this() { + _hasBits0 = other._hasBits0; + localParticipantHandle_ = other.localParticipantHandle_; + trailer_ = other.trailer_ != null ? other.trailer_.Clone() : null; + destinationIdentities_ = other.destinationIdentities_.Clone(); + senderIdentity_ = other.senderIdentity_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SendStreamTrailerRequest Clone() { + return new SendStreamTrailerRequest(this); + } + + /// Field number for the "local_participant_handle" field. + public const int LocalParticipantHandleFieldNumber = 1; + private readonly static ulong LocalParticipantHandleDefaultValue = 0UL; + + private ulong localParticipantHandle_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ulong LocalParticipantHandle { + get { if ((_hasBits0 & 1) != 0) { return localParticipantHandle_; } else { return LocalParticipantHandleDefaultValue; } } + set { + _hasBits0 |= 1; + localParticipantHandle_ = value; + } + } + /// Gets whether the "local_participant_handle" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasLocalParticipantHandle { + get { return (_hasBits0 & 1) != 0; } + } + /// Clears the value of the "local_participant_handle" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearLocalParticipantHandle() { + _hasBits0 &= ~1; + } + + /// Field number for the "trailer" field. + public const int TrailerFieldNumber = 2; + private global::LiveKit.Proto.DataStream.Types.Trailer trailer_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.DataStream.Types.Trailer Trailer { + get { return trailer_; } + set { + trailer_ = value; + } + } + + /// Field number for the "destination_identities" field. + public const int DestinationIdentitiesFieldNumber = 3; + private static readonly pb::FieldCodec _repeated_destinationIdentities_codec + = pb::FieldCodec.ForString(26); + private readonly pbc::RepeatedField destinationIdentities_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField DestinationIdentities { + get { return destinationIdentities_; } + } + + /// Field number for the "sender_identity" field. + public const int SenderIdentityFieldNumber = 4; + private readonly static string SenderIdentityDefaultValue = ""; + + private string senderIdentity_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string SenderIdentity { + get { return senderIdentity_ ?? SenderIdentityDefaultValue; } + set { + senderIdentity_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + /// Gets whether the "sender_identity" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasSenderIdentity { + get { return senderIdentity_ != null; } + } + /// Clears the value of the "sender_identity" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearSenderIdentity() { + senderIdentity_ = null; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as SendStreamTrailerRequest); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(SendStreamTrailerRequest other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (LocalParticipantHandle != other.LocalParticipantHandle) return false; + if (!object.Equals(Trailer, other.Trailer)) return false; + if(!destinationIdentities_.Equals(other.destinationIdentities_)) return false; + if (SenderIdentity != other.SenderIdentity) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (HasLocalParticipantHandle) hash ^= LocalParticipantHandle.GetHashCode(); + if (trailer_ != null) hash ^= Trailer.GetHashCode(); + hash ^= destinationIdentities_.GetHashCode(); + if (HasSenderIdentity) hash ^= SenderIdentity.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (HasLocalParticipantHandle) { + output.WriteRawTag(8); + output.WriteUInt64(LocalParticipantHandle); + } + if (trailer_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Trailer); + } + destinationIdentities_.WriteTo(output, _repeated_destinationIdentities_codec); + if (HasSenderIdentity) { + output.WriteRawTag(34); + output.WriteString(SenderIdentity); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (HasLocalParticipantHandle) { + output.WriteRawTag(8); + output.WriteUInt64(LocalParticipantHandle); + } + if (trailer_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Trailer); + } + destinationIdentities_.WriteTo(ref output, _repeated_destinationIdentities_codec); + if (HasSenderIdentity) { + output.WriteRawTag(34); + output.WriteString(SenderIdentity); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (HasLocalParticipantHandle) { + size += 1 + pb::CodedOutputStream.ComputeUInt64Size(LocalParticipantHandle); + } + if (trailer_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Trailer); + } + size += destinationIdentities_.CalculateSize(_repeated_destinationIdentities_codec); + if (HasSenderIdentity) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(SenderIdentity); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(SendStreamTrailerRequest other) { + if (other == null) { + return; + } + if (other.HasLocalParticipantHandle) { + LocalParticipantHandle = other.LocalParticipantHandle; + } + if (other.trailer_ != null) { + if (trailer_ == null) { + Trailer = new global::LiveKit.Proto.DataStream.Types.Trailer(); + } + Trailer.MergeFrom(other.Trailer); + } + destinationIdentities_.Add(other.destinationIdentities_); + if (other.HasSenderIdentity) { + SenderIdentity = other.SenderIdentity; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + LocalParticipantHandle = input.ReadUInt64(); + break; + } + case 18: { + if (trailer_ == null) { + Trailer = new global::LiveKit.Proto.DataStream.Types.Trailer(); + } + input.ReadMessage(Trailer); + break; + } + case 26: { + destinationIdentities_.AddEntriesFrom(input, _repeated_destinationIdentities_codec); + break; + } + case 34: { + SenderIdentity = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + LocalParticipantHandle = input.ReadUInt64(); + break; + } + case 18: { + if (trailer_ == null) { + Trailer = new global::LiveKit.Proto.DataStream.Types.Trailer(); + } + input.ReadMessage(Trailer); + break; + } + case 26: { + destinationIdentities_.AddEntriesFrom(ref input, _repeated_destinationIdentities_codec); + break; + } + case 34: { + SenderIdentity = input.ReadString(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class SendStreamHeaderResponse : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new SendStreamHeaderResponse()); + private pb::UnknownFieldSet _unknownFields; + private int _hasBits0; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.RoomReflection.Descriptor.MessageTypes[91]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SendStreamHeaderResponse() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SendStreamHeaderResponse(SendStreamHeaderResponse other) : this() { + _hasBits0 = other._hasBits0; + asyncId_ = other.asyncId_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SendStreamHeaderResponse Clone() { + return new SendStreamHeaderResponse(this); + } + + /// Field number for the "async_id" field. + public const int AsyncIdFieldNumber = 1; + private readonly static ulong AsyncIdDefaultValue = 0UL; + + private ulong asyncId_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ulong AsyncId { + get { if ((_hasBits0 & 1) != 0) { return asyncId_; } else { return AsyncIdDefaultValue; } } + set { + _hasBits0 |= 1; + asyncId_ = value; + } + } + /// Gets whether the "async_id" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasAsyncId { + get { return (_hasBits0 & 1) != 0; } + } + /// Clears the value of the "async_id" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearAsyncId() { + _hasBits0 &= ~1; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as SendStreamHeaderResponse); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(SendStreamHeaderResponse other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (AsyncId != other.AsyncId) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (HasAsyncId) hash ^= AsyncId.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (HasAsyncId) { + output.WriteRawTag(8); + output.WriteUInt64(AsyncId); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (HasAsyncId) { + output.WriteRawTag(8); + output.WriteUInt64(AsyncId); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (HasAsyncId) { + size += 1 + pb::CodedOutputStream.ComputeUInt64Size(AsyncId); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(SendStreamHeaderResponse other) { + if (other == null) { + return; + } + if (other.HasAsyncId) { + AsyncId = other.AsyncId; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + AsyncId = input.ReadUInt64(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + AsyncId = input.ReadUInt64(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class SendStreamChunkResponse : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new SendStreamChunkResponse()); + private pb::UnknownFieldSet _unknownFields; + private int _hasBits0; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.RoomReflection.Descriptor.MessageTypes[92]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SendStreamChunkResponse() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SendStreamChunkResponse(SendStreamChunkResponse other) : this() { + _hasBits0 = other._hasBits0; + asyncId_ = other.asyncId_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SendStreamChunkResponse Clone() { + return new SendStreamChunkResponse(this); + } + + /// Field number for the "async_id" field. + public const int AsyncIdFieldNumber = 1; + private readonly static ulong AsyncIdDefaultValue = 0UL; + + private ulong asyncId_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ulong AsyncId { + get { if ((_hasBits0 & 1) != 0) { return asyncId_; } else { return AsyncIdDefaultValue; } } + set { + _hasBits0 |= 1; + asyncId_ = value; + } + } + /// Gets whether the "async_id" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasAsyncId { + get { return (_hasBits0 & 1) != 0; } + } + /// Clears the value of the "async_id" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearAsyncId() { + _hasBits0 &= ~1; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as SendStreamChunkResponse); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(SendStreamChunkResponse other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (AsyncId != other.AsyncId) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (HasAsyncId) hash ^= AsyncId.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (HasAsyncId) { + output.WriteRawTag(8); + output.WriteUInt64(AsyncId); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (HasAsyncId) { + output.WriteRawTag(8); + output.WriteUInt64(AsyncId); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (HasAsyncId) { + size += 1 + pb::CodedOutputStream.ComputeUInt64Size(AsyncId); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(SendStreamChunkResponse other) { + if (other == null) { + return; + } + if (other.HasAsyncId) { + AsyncId = other.AsyncId; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + AsyncId = input.ReadUInt64(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + AsyncId = input.ReadUInt64(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class SendStreamTrailerResponse : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new SendStreamTrailerResponse()); + private pb::UnknownFieldSet _unknownFields; + private int _hasBits0; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.RoomReflection.Descriptor.MessageTypes[93]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SendStreamTrailerResponse() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SendStreamTrailerResponse(SendStreamTrailerResponse other) : this() { + _hasBits0 = other._hasBits0; + asyncId_ = other.asyncId_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SendStreamTrailerResponse Clone() { + return new SendStreamTrailerResponse(this); + } + + /// Field number for the "async_id" field. + public const int AsyncIdFieldNumber = 1; + private readonly static ulong AsyncIdDefaultValue = 0UL; + + private ulong asyncId_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ulong AsyncId { + get { if ((_hasBits0 & 1) != 0) { return asyncId_; } else { return AsyncIdDefaultValue; } } + set { + _hasBits0 |= 1; + asyncId_ = value; + } + } + /// Gets whether the "async_id" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasAsyncId { + get { return (_hasBits0 & 1) != 0; } + } + /// Clears the value of the "async_id" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearAsyncId() { + _hasBits0 &= ~1; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as SendStreamTrailerResponse); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(SendStreamTrailerResponse other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (AsyncId != other.AsyncId) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (HasAsyncId) hash ^= AsyncId.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (HasAsyncId) { + output.WriteRawTag(8); + output.WriteUInt64(AsyncId); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (HasAsyncId) { + output.WriteRawTag(8); + output.WriteUInt64(AsyncId); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (HasAsyncId) { + size += 1 + pb::CodedOutputStream.ComputeUInt64Size(AsyncId); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(SendStreamTrailerResponse other) { + if (other == null) { + return; + } + if (other.HasAsyncId) { + AsyncId = other.AsyncId; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + AsyncId = input.ReadUInt64(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + AsyncId = input.ReadUInt64(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class SendStreamHeaderCallback : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new SendStreamHeaderCallback()); + private pb::UnknownFieldSet _unknownFields; + private int _hasBits0; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.RoomReflection.Descriptor.MessageTypes[94]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SendStreamHeaderCallback() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SendStreamHeaderCallback(SendStreamHeaderCallback other) : this() { + _hasBits0 = other._hasBits0; + asyncId_ = other.asyncId_; + error_ = other.error_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SendStreamHeaderCallback Clone() { + return new SendStreamHeaderCallback(this); + } + + /// Field number for the "async_id" field. + public const int AsyncIdFieldNumber = 1; + private readonly static ulong AsyncIdDefaultValue = 0UL; + + private ulong asyncId_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ulong AsyncId { + get { if ((_hasBits0 & 1) != 0) { return asyncId_; } else { return AsyncIdDefaultValue; } } + set { + _hasBits0 |= 1; + asyncId_ = value; + } + } + /// Gets whether the "async_id" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasAsyncId { + get { return (_hasBits0 & 1) != 0; } + } + /// Clears the value of the "async_id" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearAsyncId() { + _hasBits0 &= ~1; + } + + /// Field number for the "error" field. + public const int ErrorFieldNumber = 2; + private readonly static string ErrorDefaultValue = ""; + + private string error_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Error { + get { return error_ ?? ErrorDefaultValue; } + set { + error_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + /// Gets whether the "error" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasError { + get { return error_ != null; } + } + /// Clears the value of the "error" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearError() { + error_ = null; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as SendStreamHeaderCallback); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(SendStreamHeaderCallback other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (AsyncId != other.AsyncId) return false; + if (Error != other.Error) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (HasAsyncId) hash ^= AsyncId.GetHashCode(); + if (HasError) hash ^= Error.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (HasAsyncId) { + output.WriteRawTag(8); + output.WriteUInt64(AsyncId); + } + if (HasError) { + output.WriteRawTag(18); + output.WriteString(Error); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (HasAsyncId) { + output.WriteRawTag(8); + output.WriteUInt64(AsyncId); + } + if (HasError) { + output.WriteRawTag(18); + output.WriteString(Error); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (HasAsyncId) { + size += 1 + pb::CodedOutputStream.ComputeUInt64Size(AsyncId); + } + if (HasError) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Error); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(SendStreamHeaderCallback other) { + if (other == null) { + return; + } + if (other.HasAsyncId) { + AsyncId = other.AsyncId; + } + if (other.HasError) { + Error = other.Error; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + AsyncId = input.ReadUInt64(); + break; + } + case 18: { + Error = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + AsyncId = input.ReadUInt64(); + break; + } + case 18: { + Error = input.ReadString(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class SendStreamChunkCallback : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new SendStreamChunkCallback()); + private pb::UnknownFieldSet _unknownFields; + private int _hasBits0; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.RoomReflection.Descriptor.MessageTypes[95]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SendStreamChunkCallback() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SendStreamChunkCallback(SendStreamChunkCallback other) : this() { + _hasBits0 = other._hasBits0; + asyncId_ = other.asyncId_; + error_ = other.error_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SendStreamChunkCallback Clone() { + return new SendStreamChunkCallback(this); + } + + /// Field number for the "async_id" field. + public const int AsyncIdFieldNumber = 1; + private readonly static ulong AsyncIdDefaultValue = 0UL; + + private ulong asyncId_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ulong AsyncId { + get { if ((_hasBits0 & 1) != 0) { return asyncId_; } else { return AsyncIdDefaultValue; } } + set { + _hasBits0 |= 1; + asyncId_ = value; + } + } + /// Gets whether the "async_id" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasAsyncId { + get { return (_hasBits0 & 1) != 0; } + } + /// Clears the value of the "async_id" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearAsyncId() { + _hasBits0 &= ~1; + } + + /// Field number for the "error" field. + public const int ErrorFieldNumber = 2; + private readonly static string ErrorDefaultValue = ""; + + private string error_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Error { + get { return error_ ?? ErrorDefaultValue; } + set { + error_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + /// Gets whether the "error" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasError { + get { return error_ != null; } + } + /// Clears the value of the "error" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearError() { + error_ = null; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as SendStreamChunkCallback); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(SendStreamChunkCallback other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (AsyncId != other.AsyncId) return false; + if (Error != other.Error) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (HasAsyncId) hash ^= AsyncId.GetHashCode(); + if (HasError) hash ^= Error.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (HasAsyncId) { + output.WriteRawTag(8); + output.WriteUInt64(AsyncId); + } + if (HasError) { + output.WriteRawTag(18); + output.WriteString(Error); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (HasAsyncId) { + output.WriteRawTag(8); + output.WriteUInt64(AsyncId); + } + if (HasError) { + output.WriteRawTag(18); + output.WriteString(Error); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (HasAsyncId) { + size += 1 + pb::CodedOutputStream.ComputeUInt64Size(AsyncId); + } + if (HasError) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Error); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(SendStreamChunkCallback other) { + if (other == null) { + return; + } + if (other.HasAsyncId) { + AsyncId = other.AsyncId; + } + if (other.HasError) { + Error = other.Error; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + AsyncId = input.ReadUInt64(); + break; + } + case 18: { + Error = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + AsyncId = input.ReadUInt64(); + break; + } + case 18: { + Error = input.ReadString(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class SendStreamTrailerCallback : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new SendStreamTrailerCallback()); + private pb::UnknownFieldSet _unknownFields; + private int _hasBits0; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.RoomReflection.Descriptor.MessageTypes[96]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SendStreamTrailerCallback() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SendStreamTrailerCallback(SendStreamTrailerCallback other) : this() { + _hasBits0 = other._hasBits0; + asyncId_ = other.asyncId_; + error_ = other.error_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SendStreamTrailerCallback Clone() { + return new SendStreamTrailerCallback(this); + } + + /// Field number for the "async_id" field. + public const int AsyncIdFieldNumber = 1; + private readonly static ulong AsyncIdDefaultValue = 0UL; + + private ulong asyncId_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ulong AsyncId { + get { if ((_hasBits0 & 1) != 0) { return asyncId_; } else { return AsyncIdDefaultValue; } } + set { + _hasBits0 |= 1; + asyncId_ = value; + } + } + /// Gets whether the "async_id" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasAsyncId { + get { return (_hasBits0 & 1) != 0; } + } + /// Clears the value of the "async_id" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearAsyncId() { + _hasBits0 &= ~1; + } + + /// Field number for the "error" field. + public const int ErrorFieldNumber = 2; + private readonly static string ErrorDefaultValue = ""; + + private string error_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Error { + get { return error_ ?? ErrorDefaultValue; } + set { + error_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + /// Gets whether the "error" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasError { + get { return error_ != null; } + } + /// Clears the value of the "error" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearError() { + error_ = null; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as SendStreamTrailerCallback); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(SendStreamTrailerCallback other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (AsyncId != other.AsyncId) return false; + if (Error != other.Error) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (HasAsyncId) hash ^= AsyncId.GetHashCode(); + if (HasError) hash ^= Error.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (HasAsyncId) { + output.WriteRawTag(8); + output.WriteUInt64(AsyncId); + } + if (HasError) { + output.WriteRawTag(18); + output.WriteString(Error); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (HasAsyncId) { + output.WriteRawTag(8); + output.WriteUInt64(AsyncId); + } + if (HasError) { + output.WriteRawTag(18); + output.WriteString(Error); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (HasAsyncId) { + size += 1 + pb::CodedOutputStream.ComputeUInt64Size(AsyncId); + } + if (HasError) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Error); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(SendStreamTrailerCallback other) { + if (other == null) { + return; + } + if (other.HasAsyncId) { + AsyncId = other.AsyncId; + } + if (other.HasError) { + Error = other.Error; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + AsyncId = input.ReadUInt64(); + break; + } + case 18: { + Error = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + AsyncId = input.ReadUInt64(); + break; + } + case 18: { + Error = input.ReadString(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class SetDataChannelBufferedAmountLowThresholdRequest : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new SetDataChannelBufferedAmountLowThresholdRequest()); + private pb::UnknownFieldSet _unknownFields; + private int _hasBits0; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.RoomReflection.Descriptor.MessageTypes[97]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SetDataChannelBufferedAmountLowThresholdRequest() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SetDataChannelBufferedAmountLowThresholdRequest(SetDataChannelBufferedAmountLowThresholdRequest other) : this() { + _hasBits0 = other._hasBits0; + localParticipantHandle_ = other.localParticipantHandle_; + threshold_ = other.threshold_; + kind_ = other.kind_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SetDataChannelBufferedAmountLowThresholdRequest Clone() { + return new SetDataChannelBufferedAmountLowThresholdRequest(this); + } + + /// Field number for the "local_participant_handle" field. + public const int LocalParticipantHandleFieldNumber = 1; + private readonly static ulong LocalParticipantHandleDefaultValue = 0UL; + + private ulong localParticipantHandle_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ulong LocalParticipantHandle { + get { if ((_hasBits0 & 1) != 0) { return localParticipantHandle_; } else { return LocalParticipantHandleDefaultValue; } } + set { + _hasBits0 |= 1; + localParticipantHandle_ = value; + } + } + /// Gets whether the "local_participant_handle" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasLocalParticipantHandle { + get { return (_hasBits0 & 1) != 0; } + } + /// Clears the value of the "local_participant_handle" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearLocalParticipantHandle() { + _hasBits0 &= ~1; + } + + /// Field number for the "threshold" field. + public const int ThresholdFieldNumber = 2; + private readonly static ulong ThresholdDefaultValue = 0UL; + + private ulong threshold_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ulong Threshold { + get { if ((_hasBits0 & 2) != 0) { return threshold_; } else { return ThresholdDefaultValue; } } + set { + _hasBits0 |= 2; + threshold_ = value; + } + } + /// Gets whether the "threshold" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasThreshold { + get { return (_hasBits0 & 2) != 0; } + } + /// Clears the value of the "threshold" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearThreshold() { + _hasBits0 &= ~2; + } + + /// Field number for the "kind" field. + public const int KindFieldNumber = 3; + private readonly static global::LiveKit.Proto.DataPacketKind KindDefaultValue = global::LiveKit.Proto.DataPacketKind.KindLossy; + + private global::LiveKit.Proto.DataPacketKind kind_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.DataPacketKind Kind { + get { if ((_hasBits0 & 4) != 0) { return kind_; } else { return KindDefaultValue; } } + set { + _hasBits0 |= 4; + kind_ = value; + } + } + /// Gets whether the "kind" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasKind { + get { return (_hasBits0 & 4) != 0; } + } + /// Clears the value of the "kind" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearKind() { + _hasBits0 &= ~4; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as SetDataChannelBufferedAmountLowThresholdRequest); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(SetDataChannelBufferedAmountLowThresholdRequest other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (LocalParticipantHandle != other.LocalParticipantHandle) return false; + if (Threshold != other.Threshold) return false; + if (Kind != other.Kind) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (HasLocalParticipantHandle) hash ^= LocalParticipantHandle.GetHashCode(); + if (HasThreshold) hash ^= Threshold.GetHashCode(); + if (HasKind) hash ^= Kind.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (HasLocalParticipantHandle) { + output.WriteRawTag(8); + output.WriteUInt64(LocalParticipantHandle); + } + if (HasThreshold) { + output.WriteRawTag(16); + output.WriteUInt64(Threshold); + } + if (HasKind) { + output.WriteRawTag(24); + output.WriteEnum((int) Kind); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (HasLocalParticipantHandle) { + output.WriteRawTag(8); + output.WriteUInt64(LocalParticipantHandle); + } + if (HasThreshold) { + output.WriteRawTag(16); + output.WriteUInt64(Threshold); + } + if (HasKind) { + output.WriteRawTag(24); + output.WriteEnum((int) Kind); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (HasLocalParticipantHandle) { + size += 1 + pb::CodedOutputStream.ComputeUInt64Size(LocalParticipantHandle); + } + if (HasThreshold) { + size += 1 + pb::CodedOutputStream.ComputeUInt64Size(Threshold); + } + if (HasKind) { + size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) Kind); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(SetDataChannelBufferedAmountLowThresholdRequest other) { + if (other == null) { + return; + } + if (other.HasLocalParticipantHandle) { + LocalParticipantHandle = other.LocalParticipantHandle; + } + if (other.HasThreshold) { + Threshold = other.Threshold; + } + if (other.HasKind) { + Kind = other.Kind; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + LocalParticipantHandle = input.ReadUInt64(); + break; + } + case 16: { + Threshold = input.ReadUInt64(); + break; + } + case 24: { + Kind = (global::LiveKit.Proto.DataPacketKind) input.ReadEnum(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + LocalParticipantHandle = input.ReadUInt64(); + break; + } + case 16: { + Threshold = input.ReadUInt64(); + break; + } + case 24: { + Kind = (global::LiveKit.Proto.DataPacketKind) input.ReadEnum(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class SetDataChannelBufferedAmountLowThresholdResponse : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new SetDataChannelBufferedAmountLowThresholdResponse()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.RoomReflection.Descriptor.MessageTypes[98]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SetDataChannelBufferedAmountLowThresholdResponse() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SetDataChannelBufferedAmountLowThresholdResponse(SetDataChannelBufferedAmountLowThresholdResponse other) : this() { + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SetDataChannelBufferedAmountLowThresholdResponse Clone() { + return new SetDataChannelBufferedAmountLowThresholdResponse(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as SetDataChannelBufferedAmountLowThresholdResponse); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(SetDataChannelBufferedAmountLowThresholdResponse other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(SetDataChannelBufferedAmountLowThresholdResponse other) { + if (other == null) { + return; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class DataChannelBufferedAmountLowThresholdChanged : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new DataChannelBufferedAmountLowThresholdChanged()); + private pb::UnknownFieldSet _unknownFields; + private int _hasBits0; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.RoomReflection.Descriptor.MessageTypes[99]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public DataChannelBufferedAmountLowThresholdChanged() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public DataChannelBufferedAmountLowThresholdChanged(DataChannelBufferedAmountLowThresholdChanged other) : this() { + _hasBits0 = other._hasBits0; + kind_ = other.kind_; + threshold_ = other.threshold_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public DataChannelBufferedAmountLowThresholdChanged Clone() { + return new DataChannelBufferedAmountLowThresholdChanged(this); + } + + /// Field number for the "kind" field. + public const int KindFieldNumber = 1; + private readonly static global::LiveKit.Proto.DataPacketKind KindDefaultValue = global::LiveKit.Proto.DataPacketKind.KindLossy; + + private global::LiveKit.Proto.DataPacketKind kind_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.DataPacketKind Kind { + get { if ((_hasBits0 & 1) != 0) { return kind_; } else { return KindDefaultValue; } } + set { + _hasBits0 |= 1; + kind_ = value; + } + } + /// Gets whether the "kind" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasKind { + get { return (_hasBits0 & 1) != 0; } + } + /// Clears the value of the "kind" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearKind() { + _hasBits0 &= ~1; + } + + /// Field number for the "threshold" field. + public const int ThresholdFieldNumber = 2; + private readonly static ulong ThresholdDefaultValue = 0UL; + + private ulong threshold_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ulong Threshold { + get { if ((_hasBits0 & 2) != 0) { return threshold_; } else { return ThresholdDefaultValue; } } + set { + _hasBits0 |= 2; + threshold_ = value; + } + } + /// Gets whether the "threshold" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasThreshold { + get { return (_hasBits0 & 2) != 0; } + } + /// Clears the value of the "threshold" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearThreshold() { + _hasBits0 &= ~2; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as DataChannelBufferedAmountLowThresholdChanged); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(DataChannelBufferedAmountLowThresholdChanged other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Kind != other.Kind) return false; + if (Threshold != other.Threshold) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (HasKind) hash ^= Kind.GetHashCode(); + if (HasThreshold) hash ^= Threshold.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (HasKind) { + output.WriteRawTag(8); + output.WriteEnum((int) Kind); + } + if (HasThreshold) { + output.WriteRawTag(16); + output.WriteUInt64(Threshold); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (HasKind) { + output.WriteRawTag(8); + output.WriteEnum((int) Kind); + } + if (HasThreshold) { + output.WriteRawTag(16); + output.WriteUInt64(Threshold); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (HasKind) { + size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) Kind); + } + if (HasThreshold) { + size += 1 + pb::CodedOutputStream.ComputeUInt64Size(Threshold); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(DataChannelBufferedAmountLowThresholdChanged other) { + if (other == null) { + return; + } + if (other.HasKind) { + Kind = other.Kind; + } + if (other.HasThreshold) { + Threshold = other.Threshold; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + Kind = (global::LiveKit.Proto.DataPacketKind) input.ReadEnum(); + break; + } + case 16: { + Threshold = input.ReadUInt64(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + Kind = (global::LiveKit.Proto.DataPacketKind) input.ReadEnum(); + break; + } + case 16: { + Threshold = input.ReadUInt64(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class ByteStreamOpened : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ByteStreamOpened()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.RoomReflection.Descriptor.MessageTypes[100]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ByteStreamOpened() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ByteStreamOpened(ByteStreamOpened other) : this() { + reader_ = other.reader_ != null ? other.reader_.Clone() : null; + participantIdentity_ = other.participantIdentity_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ByteStreamOpened Clone() { + return new ByteStreamOpened(this); + } + + /// Field number for the "reader" field. + public const int ReaderFieldNumber = 1; + private global::LiveKit.Proto.OwnedByteStreamReader reader_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.OwnedByteStreamReader Reader { + get { return reader_; } + set { + reader_ = value; + } + } + + /// Field number for the "participant_identity" field. + public const int ParticipantIdentityFieldNumber = 2; + private readonly static string ParticipantIdentityDefaultValue = ""; + + private string participantIdentity_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string ParticipantIdentity { + get { return participantIdentity_ ?? ParticipantIdentityDefaultValue; } + set { + participantIdentity_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + /// Gets whether the "participant_identity" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasParticipantIdentity { + get { return participantIdentity_ != null; } + } + /// Clears the value of the "participant_identity" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearParticipantIdentity() { + participantIdentity_ = null; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as ByteStreamOpened); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(ByteStreamOpened other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (!object.Equals(Reader, other.Reader)) return false; + if (ParticipantIdentity != other.ParticipantIdentity) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (reader_ != null) hash ^= Reader.GetHashCode(); + if (HasParticipantIdentity) hash ^= ParticipantIdentity.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (reader_ != null) { + output.WriteRawTag(10); + output.WriteMessage(Reader); + } + if (HasParticipantIdentity) { + output.WriteRawTag(18); + output.WriteString(ParticipantIdentity); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (reader_ != null) { + output.WriteRawTag(10); + output.WriteMessage(Reader); + } + if (HasParticipantIdentity) { + output.WriteRawTag(18); + output.WriteString(ParticipantIdentity); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (reader_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Reader); + } + if (HasParticipantIdentity) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(ParticipantIdentity); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(ByteStreamOpened other) { + if (other == null) { + return; + } + if (other.reader_ != null) { + if (reader_ == null) { + Reader = new global::LiveKit.Proto.OwnedByteStreamReader(); + } + Reader.MergeFrom(other.Reader); + } + if (other.HasParticipantIdentity) { + ParticipantIdentity = other.ParticipantIdentity; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + if (reader_ == null) { + Reader = new global::LiveKit.Proto.OwnedByteStreamReader(); + } + input.ReadMessage(Reader); + break; + } + case 18: { + ParticipantIdentity = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + if (reader_ == null) { + Reader = new global::LiveKit.Proto.OwnedByteStreamReader(); + } + input.ReadMessage(Reader); + break; + } + case 18: { + ParticipantIdentity = input.ReadString(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class TextStreamOpened : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new TextStreamOpened()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.RoomReflection.Descriptor.MessageTypes[101]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TextStreamOpened() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TextStreamOpened(TextStreamOpened other) : this() { + reader_ = other.reader_ != null ? other.reader_.Clone() : null; + participantIdentity_ = other.participantIdentity_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public TextStreamOpened Clone() { + return new TextStreamOpened(this); + } + + /// Field number for the "reader" field. + public const int ReaderFieldNumber = 1; + private global::LiveKit.Proto.OwnedTextStreamReader reader_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.OwnedTextStreamReader Reader { + get { return reader_; } + set { + reader_ = value; + } + } + + /// Field number for the "participant_identity" field. + public const int ParticipantIdentityFieldNumber = 2; + private readonly static string ParticipantIdentityDefaultValue = ""; + + private string participantIdentity_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string ParticipantIdentity { + get { return participantIdentity_ ?? ParticipantIdentityDefaultValue; } + set { + participantIdentity_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + /// Gets whether the "participant_identity" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasParticipantIdentity { + get { return participantIdentity_ != null; } + } + /// Clears the value of the "participant_identity" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearParticipantIdentity() { + participantIdentity_ = null; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as TextStreamOpened); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(TextStreamOpened other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (!object.Equals(Reader, other.Reader)) return false; + if (ParticipantIdentity != other.ParticipantIdentity) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (reader_ != null) hash ^= Reader.GetHashCode(); + if (HasParticipantIdentity) hash ^= ParticipantIdentity.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (reader_ != null) { + output.WriteRawTag(10); + output.WriteMessage(Reader); + } + if (HasParticipantIdentity) { + output.WriteRawTag(18); + output.WriteString(ParticipantIdentity); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (reader_ != null) { + output.WriteRawTag(10); + output.WriteMessage(Reader); + } + if (HasParticipantIdentity) { + output.WriteRawTag(18); + output.WriteString(ParticipantIdentity); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (reader_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Reader); + } + if (HasParticipantIdentity) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(ParticipantIdentity); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(TextStreamOpened other) { + if (other == null) { + return; + } + if (other.reader_ != null) { + if (reader_ == null) { + Reader = new global::LiveKit.Proto.OwnedTextStreamReader(); + } + Reader.MergeFrom(other.Reader); + } + if (other.HasParticipantIdentity) { + ParticipantIdentity = other.ParticipantIdentity; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + if (reader_ == null) { + Reader = new global::LiveKit.Proto.OwnedTextStreamReader(); + } + input.ReadMessage(Reader); + break; + } + case 18: { + ParticipantIdentity = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + if (reader_ == null) { + Reader = new global::LiveKit.Proto.OwnedTextStreamReader(); + } + input.ReadMessage(Reader); + break; + } + case 18: { + ParticipantIdentity = input.ReadString(); + break; + } + } + } + } + #endif + + } + #endregion } diff --git a/Runtime/Scripts/Proto/Stats.cs b/Runtime/Scripts/Proto/Stats.cs index 12d5f9c1..aad800b2 100644 --- a/Runtime/Scripts/Proto/Stats.cs +++ b/Runtime/Scripts/Proto/Stats.cs @@ -24,7 +24,7 @@ public static partial class StatsReflection { static StatsReflection() { byte[] descriptorData = global::System.Convert.FromBase64String( string.Concat( - "CgtzdGF0cy5wcm90bxINbGl2ZWtpdC5wcm90byLZFwoIUnRjU3RhdHMSLgoF", + "CgtzdGF0cy5wcm90bxINbGl2ZWtpdC5wcm90byLrGAoIUnRjU3RhdHMSLgoF", "Y29kZWMYAyABKAsyHS5saXZla2l0LnByb3RvLlJ0Y1N0YXRzLkNvZGVjSAAS", "OQoLaW5ib3VuZF9ydHAYBCABKAsyIi5saXZla2l0LnByb3RvLlJ0Y1N0YXRz", "LkluYm91bmRSdHBIABI7CgxvdXRib3VuZF9ydHAYBSABKAsyIy5saXZla2l0", @@ -44,216 +44,221 @@ static StatsReflection() { "cm90by5SdGNTdGF0cy5Mb2NhbENhbmRpZGF0ZUgAEkMKEHJlbW90ZV9jYW5k", "aWRhdGUYDyABKAsyJy5saXZla2l0LnByb3RvLlJ0Y1N0YXRzLlJlbW90ZUNh", "bmRpZGF0ZUgAEjoKC2NlcnRpZmljYXRlGBAgASgLMiMubGl2ZWtpdC5wcm90", - "by5SdGNTdGF0cy5DZXJ0aWZpY2F0ZUgAEi4KBXRyYWNrGBEgASgLMh0ubGl2", - "ZWtpdC5wcm90by5SdGNTdGF0cy5UcmFja0gAGlsKBUNvZGVjEigKA3J0YxgB", - "IAIoCzIbLmxpdmVraXQucHJvdG8uUnRjU3RhdHNEYXRhEigKBWNvZGVjGAIg", - "AigLMhkubGl2ZWtpdC5wcm90by5Db2RlY1N0YXRzGtUBCgpJbmJvdW5kUnRw", - "EigKA3J0YxgBIAIoCzIbLmxpdmVraXQucHJvdG8uUnRjU3RhdHNEYXRhEi0K", - "BnN0cmVhbRgCIAIoCzIdLmxpdmVraXQucHJvdG8uUnRwU3RyZWFtU3RhdHMS", - "NwoIcmVjZWl2ZWQYAyACKAsyJS5saXZla2l0LnByb3RvLlJlY2VpdmVkUnRw", - "U3RyZWFtU3RhdHMSNQoHaW5ib3VuZBgEIAIoCzIkLmxpdmVraXQucHJvdG8u", - "SW5ib3VuZFJ0cFN0cmVhbVN0YXRzGtABCgtPdXRib3VuZFJ0cBIoCgNydGMY", - "ASACKAsyGy5saXZla2l0LnByb3RvLlJ0Y1N0YXRzRGF0YRItCgZzdHJlYW0Y", - "AiACKAsyHS5saXZla2l0LnByb3RvLlJ0cFN0cmVhbVN0YXRzEi8KBHNlbnQY", - "AyACKAsyIS5saXZla2l0LnByb3RvLlNlbnRSdHBTdHJlYW1TdGF0cxI3Cghv", - "dXRib3VuZBgEIAIoCzIlLmxpdmVraXQucHJvdG8uT3V0Ym91bmRSdHBTdHJl", - "YW1TdGF0cxroAQoQUmVtb3RlSW5ib3VuZFJ0cBIoCgNydGMYASACKAsyGy5s", - "aXZla2l0LnByb3RvLlJ0Y1N0YXRzRGF0YRItCgZzdHJlYW0YAiACKAsyHS5s", - "aXZla2l0LnByb3RvLlJ0cFN0cmVhbVN0YXRzEjcKCHJlY2VpdmVkGAMgAigL", - "MiUubGl2ZWtpdC5wcm90by5SZWNlaXZlZFJ0cFN0cmVhbVN0YXRzEkIKDnJl", - "bW90ZV9pbmJvdW5kGAQgAigLMioubGl2ZWtpdC5wcm90by5SZW1vdGVJbmJv", - "dW5kUnRwU3RyZWFtU3RhdHMa4wEKEVJlbW90ZU91dGJvdW5kUnRwEigKA3J0", - "YxgBIAIoCzIbLmxpdmVraXQucHJvdG8uUnRjU3RhdHNEYXRhEi0KBnN0cmVh", - "bRgCIAIoCzIdLmxpdmVraXQucHJvdG8uUnRwU3RyZWFtU3RhdHMSLwoEc2Vu", - "dBgDIAIoCzIhLmxpdmVraXQucHJvdG8uU2VudFJ0cFN0cmVhbVN0YXRzEkQK", - "D3JlbW90ZV9vdXRib3VuZBgEIAIoCzIrLmxpdmVraXQucHJvdG8uUmVtb3Rl", - "T3V0Ym91bmRSdHBTdHJlYW1TdGF0cxrIAQoLTWVkaWFTb3VyY2USKAoDcnRj", - "GAEgAigLMhsubGl2ZWtpdC5wcm90by5SdGNTdGF0c0RhdGESLwoGc291cmNl", - "GAIgAigLMh8ubGl2ZWtpdC5wcm90by5NZWRpYVNvdXJjZVN0YXRzEi4KBWF1", - "ZGlvGAMgAigLMh8ubGl2ZWtpdC5wcm90by5BdWRpb1NvdXJjZVN0YXRzEi4K", - "BXZpZGVvGAQgAigLMh8ubGl2ZWtpdC5wcm90by5WaWRlb1NvdXJjZVN0YXRz", - "GnEKDE1lZGlhUGxheW91dBIoCgNydGMYASACKAsyGy5saXZla2l0LnByb3Rv", - "LlJ0Y1N0YXRzRGF0YRI3Cg1hdWRpb19wbGF5b3V0GAIgAigLMiAubGl2ZWtp", - "dC5wcm90by5BdWRpb1BsYXlvdXRTdGF0cxpqCg5QZWVyQ29ubmVjdGlvbhIo", - "CgNydGMYASACKAsyGy5saXZla2l0LnByb3RvLlJ0Y1N0YXRzRGF0YRIuCgJw", - "YxgCIAIoCzIiLmxpdmVraXQucHJvdG8uUGVlckNvbm5lY3Rpb25TdGF0cxpk", - "CgtEYXRhQ2hhbm5lbBIoCgNydGMYASACKAsyGy5saXZla2l0LnByb3RvLlJ0", - "Y1N0YXRzRGF0YRIrCgJkYxgCIAIoCzIfLmxpdmVraXQucHJvdG8uRGF0YUNo", - "YW5uZWxTdGF0cxpnCglUcmFuc3BvcnQSKAoDcnRjGAEgAigLMhsubGl2ZWtp", - "dC5wcm90by5SdGNTdGF0c0RhdGESMAoJdHJhbnNwb3J0GAIgAigLMh0ubGl2", - "ZWtpdC5wcm90by5UcmFuc3BvcnRTdGF0cxp0Cg1DYW5kaWRhdGVQYWlyEigK", - "A3J0YxgBIAIoCzIbLmxpdmVraXQucHJvdG8uUnRjU3RhdHNEYXRhEjkKDmNh", - "bmRpZGF0ZV9wYWlyGAIgAigLMiEubGl2ZWtpdC5wcm90by5DYW5kaWRhdGVQ", - "YWlyU3RhdHMabwoOTG9jYWxDYW5kaWRhdGUSKAoDcnRjGAEgAigLMhsubGl2", - "ZWtpdC5wcm90by5SdGNTdGF0c0RhdGESMwoJY2FuZGlkYXRlGAIgAigLMiAu", - "bGl2ZWtpdC5wcm90by5JY2VDYW5kaWRhdGVTdGF0cxpwCg9SZW1vdGVDYW5k", - "aWRhdGUSKAoDcnRjGAEgAigLMhsubGl2ZWtpdC5wcm90by5SdGNTdGF0c0Rh", - "dGESMwoJY2FuZGlkYXRlGAIgAigLMiAubGl2ZWtpdC5wcm90by5JY2VDYW5k", - "aWRhdGVTdGF0cxptCgtDZXJ0aWZpY2F0ZRIoCgNydGMYASACKAsyGy5saXZl", - "a2l0LnByb3RvLlJ0Y1N0YXRzRGF0YRI0CgtjZXJ0aWZpY2F0ZRgCIAIoCzIf", - "LmxpdmVraXQucHJvdG8uQ2VydGlmaWNhdGVTdGF0cxoHCgVUcmFja0IHCgVz", - "dGF0cyItCgxSdGNTdGF0c0RhdGESCgoCaWQYASACKAkSEQoJdGltZXN0YW1w", - "GAIgAigDIogBCgpDb2RlY1N0YXRzEhQKDHBheWxvYWRfdHlwZRgBIAIoDRIU", - "Cgx0cmFuc3BvcnRfaWQYAiACKAkSEQoJbWltZV90eXBlGAMgAigJEhIKCmNs", - "b2NrX3JhdGUYBCACKA0SEAoIY2hhbm5lbHMYBSACKA0SFQoNc2RwX2ZtdHBf", - "bGluZRgGIAIoCSJUCg5SdHBTdHJlYW1TdGF0cxIMCgRzc3JjGAEgAigNEgwK", - "BGtpbmQYAiACKAkSFAoMdHJhbnNwb3J0X2lkGAMgAigJEhAKCGNvZGVjX2lk", - "GAQgAigJIlgKFlJlY2VpdmVkUnRwU3RyZWFtU3RhdHMSGAoQcGFja2V0c19y", - "ZWNlaXZlZBgBIAIoBBIUCgxwYWNrZXRzX2xvc3QYAiACKAMSDgoGaml0dGVy", - "GAMgAigBIoIMChVJbmJvdW5kUnRwU3RyZWFtU3RhdHMSGAoQdHJhY2tfaWRl", - "bnRpZmllchgBIAIoCRILCgNtaWQYAiACKAkSEQoJcmVtb3RlX2lkGAMgAigJ", - "EhYKDmZyYW1lc19kZWNvZGVkGAQgAigNEhoKEmtleV9mcmFtZXNfZGVjb2Rl", - "ZBgFIAIoDRIXCg9mcmFtZXNfcmVuZGVyZWQYBiACKA0SFgoOZnJhbWVzX2Ry", - "b3BwZWQYByACKA0SEwoLZnJhbWVfd2lkdGgYCCACKA0SFAoMZnJhbWVfaGVp", - "Z2h0GAkgAigNEhkKEWZyYW1lc19wZXJfc2Vjb25kGAogAigBEg4KBnFwX3N1", - "bRgLIAIoBBIZChF0b3RhbF9kZWNvZGVfdGltZRgMIAIoARIfChd0b3RhbF9p", - "bnRlcl9mcmFtZV9kZWxheRgNIAIoARInCh90b3RhbF9zcXVhcmVkX2ludGVy", - "X2ZyYW1lX2RlbGF5GA4gAigBEhMKC3BhdXNlX2NvdW50GA8gAigNEhwKFHRv", - "dGFsX3BhdXNlX2R1cmF0aW9uGBAgAigBEhQKDGZyZWV6ZV9jb3VudBgRIAIo", - "DRIdChV0b3RhbF9mcmVlemVfZHVyYXRpb24YEiACKAESJgoebGFzdF9wYWNr", - "ZXRfcmVjZWl2ZWRfdGltZXN0YW1wGBMgAigBEh0KFWhlYWRlcl9ieXRlc19y", - "ZWNlaXZlZBgUIAIoBBIZChFwYWNrZXRzX2Rpc2NhcmRlZBgVIAIoBBIaChJm", - "ZWNfYnl0ZXNfcmVjZWl2ZWQYFiACKAQSHAoUZmVjX3BhY2tldHNfcmVjZWl2", - "ZWQYFyACKAQSHQoVZmVjX3BhY2tldHNfZGlzY2FyZGVkGBggAigEEhYKDmJ5", - "dGVzX3JlY2VpdmVkGBkgAigEEhIKCm5hY2tfY291bnQYGiACKA0SEQoJZmly", - "X2NvdW50GBsgAigNEhEKCXBsaV9jb3VudBgcIAIoDRIeChZ0b3RhbF9wcm9j", - "ZXNzaW5nX2RlbGF5GB0gAigBEiMKG2VzdGltYXRlZF9wbGF5b3V0X3RpbWVz", - "dGFtcBgeIAIoARIbChNqaXR0ZXJfYnVmZmVyX2RlbGF5GB8gAigBEiIKGmpp", - "dHRlcl9idWZmZXJfdGFyZ2V0X2RlbGF5GCAgAigBEiMKG2ppdHRlcl9idWZm", - "ZXJfZW1pdHRlZF9jb3VudBghIAIoBBIjChtqaXR0ZXJfYnVmZmVyX21pbmlt", - "dW1fZGVsYXkYIiACKAESHgoWdG90YWxfc2FtcGxlc19yZWNlaXZlZBgjIAIo", - "BBIZChFjb25jZWFsZWRfc2FtcGxlcxgkIAIoBBIgChhzaWxlbnRfY29uY2Vh", - "bGVkX3NhbXBsZXMYJSACKAQSGgoSY29uY2VhbG1lbnRfZXZlbnRzGCYgAigE", - "EikKIWluc2VydGVkX3NhbXBsZXNfZm9yX2RlY2VsZXJhdGlvbhgnIAIoBBIo", - "CiByZW1vdmVkX3NhbXBsZXNfZm9yX2FjY2VsZXJhdGlvbhgoIAIoBBITCgth", - "dWRpb19sZXZlbBgpIAIoARIaChJ0b3RhbF9hdWRpb19lbmVyZ3kYKiACKAES", - "HgoWdG90YWxfc2FtcGxlc19kdXJhdGlvbhgrIAIoARIXCg9mcmFtZXNfcmVj", - "ZWl2ZWQYLCACKAQSHgoWZGVjb2Rlcl9pbXBsZW1lbnRhdGlvbhgtIAIoCRIS", - "CgpwbGF5b3V0X2lkGC4gAigJEh8KF3Bvd2VyX2VmZmljaWVudF9kZWNvZGVy", - "GC8gAigIEi4KJmZyYW1lc19hc3NlbWJsZWRfZnJvbV9tdWx0aXBsZV9wYWNr", - "ZXRzGDAgAigEEhsKE3RvdGFsX2Fzc2VtYmx5X3RpbWUYMSACKAESJgoecmV0", - "cmFuc21pdHRlZF9wYWNrZXRzX3JlY2VpdmVkGDIgAigEEiQKHHJldHJhbnNt", - "aXR0ZWRfYnl0ZXNfcmVjZWl2ZWQYMyACKAQSEAoIcnR4X3NzcmMYNCACKA0S", - "EAoIZmVjX3NzcmMYNSACKA0iPgoSU2VudFJ0cFN0cmVhbVN0YXRzEhQKDHBh", - "Y2tldHNfc2VudBgBIAIoBBISCgpieXRlc19zZW50GAIgAigEItEHChZPdXRi", - "b3VuZFJ0cFN0cmVhbVN0YXRzEgsKA21pZBgBIAIoCRIXCg9tZWRpYV9zb3Vy", - "Y2VfaWQYAiACKAkSEQoJcmVtb3RlX2lkGAMgAigJEgsKA3JpZBgEIAIoCRIZ", - "ChFoZWFkZXJfYnl0ZXNfc2VudBgFIAIoBBIiChpyZXRyYW5zbWl0dGVkX3Bh", - "Y2tldHNfc2VudBgGIAIoBBIgChhyZXRyYW5zbWl0dGVkX2J5dGVzX3NlbnQY", - "ByACKAQSEAoIcnR4X3NzcmMYCCACKA0SFgoOdGFyZ2V0X2JpdHJhdGUYCSAC", - "KAESIgoadG90YWxfZW5jb2RlZF9ieXRlc190YXJnZXQYCiACKAQSEwoLZnJh", - "bWVfd2lkdGgYCyACKA0SFAoMZnJhbWVfaGVpZ2h0GAwgAigNEhkKEWZyYW1l", - "c19wZXJfc2Vjb25kGA0gAigBEhMKC2ZyYW1lc19zZW50GA4gAigNEhgKEGh1", - "Z2VfZnJhbWVzX3NlbnQYDyACKA0SFgoOZnJhbWVzX2VuY29kZWQYECACKA0S", - "GgoSa2V5X2ZyYW1lc19lbmNvZGVkGBEgAigNEg4KBnFwX3N1bRgSIAIoBBIZ", - "ChF0b3RhbF9lbmNvZGVfdGltZRgTIAIoARIfChd0b3RhbF9wYWNrZXRfc2Vu", - "ZF9kZWxheRgUIAIoARJJChlxdWFsaXR5X2xpbWl0YXRpb25fcmVhc29uGBUg", - "AigOMiYubGl2ZWtpdC5wcm90by5RdWFsaXR5TGltaXRhdGlvblJlYXNvbhJr", - "ChxxdWFsaXR5X2xpbWl0YXRpb25fZHVyYXRpb25zGBYgAygLMkUubGl2ZWtp", - "dC5wcm90by5PdXRib3VuZFJ0cFN0cmVhbVN0YXRzLlF1YWxpdHlMaW1pdGF0", - "aW9uRHVyYXRpb25zRW50cnkSLQolcXVhbGl0eV9saW1pdGF0aW9uX3Jlc29s", - "dXRpb25fY2hhbmdlcxgXIAIoDRISCgpuYWNrX2NvdW50GBggAigNEhEKCWZp", - "cl9jb3VudBgZIAIoDRIRCglwbGlfY291bnQYGiACKA0SHgoWZW5jb2Rlcl9p", - "bXBsZW1lbnRhdGlvbhgbIAIoCRIfChdwb3dlcl9lZmZpY2llbnRfZW5jb2Rl", - "chgcIAIoCBIOCgZhY3RpdmUYHSACKAgSGAoQc2NhbGFiaWxpdHlfbW9kZRge", - "IAIoCRpBCh9RdWFsaXR5TGltaXRhdGlvbkR1cmF0aW9uc0VudHJ5EgsKA2tl", - "eRgBIAEoCRINCgV2YWx1ZRgCIAEoAToCOAEipAEKG1JlbW90ZUluYm91bmRS", - "dHBTdHJlYW1TdGF0cxIQCghsb2NhbF9pZBgBIAIoCRIXCg9yb3VuZF90cmlw", - "X3RpbWUYAiACKAESHQoVdG90YWxfcm91bmRfdHJpcF90aW1lGAMgAigBEhUK", - "DWZyYWN0aW9uX2xvc3QYBCACKAESJAoccm91bmRfdHJpcF90aW1lX21lYXN1", - "cmVtZW50cxgFIAIoBCK+AQocUmVtb3RlT3V0Ym91bmRSdHBTdHJlYW1TdGF0", - "cxIQCghsb2NhbF9pZBgBIAIoCRIYChByZW1vdGVfdGltZXN0YW1wGAIgAigB", - "EhQKDHJlcG9ydHNfc2VudBgDIAIoBBIXCg9yb3VuZF90cmlwX3RpbWUYBCAC", - "KAESHQoVdG90YWxfcm91bmRfdHJpcF90aW1lGAUgAigBEiQKHHJvdW5kX3Ry", - "aXBfdGltZV9tZWFzdXJlbWVudHMYBiACKAQiOgoQTWVkaWFTb3VyY2VTdGF0", - "cxIYChB0cmFja19pZGVudGlmaWVyGAEgAigJEgwKBGtpbmQYAiACKAkiogIK", - "EEF1ZGlvU291cmNlU3RhdHMSEwoLYXVkaW9fbGV2ZWwYASACKAESGgoSdG90", - "YWxfYXVkaW9fZW5lcmd5GAIgAigBEh4KFnRvdGFsX3NhbXBsZXNfZHVyYXRp", - "b24YAyACKAESGAoQZWNob19yZXR1cm5fbG9zcxgEIAIoARIkChxlY2hvX3Jl", - "dHVybl9sb3NzX2VuaGFuY2VtZW50GAUgAigBEiAKGGRyb3BwZWRfc2FtcGxl", - "c19kdXJhdGlvbhgGIAIoARIeChZkcm9wcGVkX3NhbXBsZXNfZXZlbnRzGAcg", - "AigNEhsKE3RvdGFsX2NhcHR1cmVfZGVsYXkYCCACKAESHgoWdG90YWxfc2Ft", - "cGxlc19jYXB0dXJlZBgJIAIoBCJcChBWaWRlb1NvdXJjZVN0YXRzEg0KBXdp", - "ZHRoGAEgAigNEg4KBmhlaWdodBgCIAIoDRIOCgZmcmFtZXMYAyACKA0SGQoR", - "ZnJhbWVzX3Blcl9zZWNvbmQYBCACKAEixQEKEUF1ZGlvUGxheW91dFN0YXRz", - "EgwKBGtpbmQYASACKAkSJAocc3ludGhlc2l6ZWRfc2FtcGxlc19kdXJhdGlv", - "bhgCIAIoARIiChpzeW50aGVzaXplZF9zYW1wbGVzX2V2ZW50cxgDIAIoDRIe", - "ChZ0b3RhbF9zYW1wbGVzX2R1cmF0aW9uGAQgAigBEhsKE3RvdGFsX3BsYXlv", - "dXRfZGVsYXkYBSACKAESGwoTdG90YWxfc2FtcGxlc19jb3VudBgGIAIoBCJR", - "ChNQZWVyQ29ubmVjdGlvblN0YXRzEhwKFGRhdGFfY2hhbm5lbHNfb3BlbmVk", - "GAEgAigNEhwKFGRhdGFfY2hhbm5lbHNfY2xvc2VkGAIgAigNIuIBChBEYXRh", - "Q2hhbm5lbFN0YXRzEg0KBWxhYmVsGAEgAigJEhAKCHByb3RvY29sGAIgAigJ", - "Eh8KF2RhdGFfY2hhbm5lbF9pZGVudGlmaWVyGAMgAigFEi4KBXN0YXRlGAQg", - "ASgOMh8ubGl2ZWtpdC5wcm90by5EYXRhQ2hhbm5lbFN0YXRlEhUKDW1lc3Nh", - "Z2VzX3NlbnQYBSACKA0SEgoKYnl0ZXNfc2VudBgGIAIoBBIZChFtZXNzYWdl", - "c19yZWNlaXZlZBgHIAIoDRIWCg5ieXRlc19yZWNlaXZlZBgIIAIoBCKcBAoO", - "VHJhbnNwb3J0U3RhdHMSFAoMcGFja2V0c19zZW50GAEgAigEEhgKEHBhY2tl", - "dHNfcmVjZWl2ZWQYAiACKAQSEgoKYnl0ZXNfc2VudBgDIAIoBBIWCg5ieXRl", - "c19yZWNlaXZlZBgEIAIoBBIoCghpY2Vfcm9sZRgFIAIoDjIWLmxpdmVraXQu", - "cHJvdG8uSWNlUm9sZRIjChtpY2VfbG9jYWxfdXNlcm5hbWVfZnJhZ21lbnQY", - "BiACKAkSNQoKZHRsc19zdGF0ZRgHIAEoDjIhLmxpdmVraXQucHJvdG8uRHRs", - "c1RyYW5zcG9ydFN0YXRlEjMKCWljZV9zdGF0ZRgIIAEoDjIgLmxpdmVraXQu", - "cHJvdG8uSWNlVHJhbnNwb3J0U3RhdGUSIgoac2VsZWN0ZWRfY2FuZGlkYXRl", - "X3BhaXJfaWQYCSACKAkSHAoUbG9jYWxfY2VydGlmaWNhdGVfaWQYCiACKAkS", - "HQoVcmVtb3RlX2NlcnRpZmljYXRlX2lkGAsgAigJEhMKC3Rsc192ZXJzaW9u", - "GAwgAigJEhMKC2R0bHNfY2lwaGVyGA0gAigJEioKCWR0bHNfcm9sZRgOIAIo", - "DjIXLmxpdmVraXQucHJvdG8uRHRsc1JvbGUSEwoLc3J0cF9jaXBoZXIYDyAC", - "KAkSJwofc2VsZWN0ZWRfY2FuZGlkYXRlX3BhaXJfY2hhbmdlcxgQIAIoDSKk", - "BQoSQ2FuZGlkYXRlUGFpclN0YXRzEhQKDHRyYW5zcG9ydF9pZBgBIAIoCRIa", - "ChJsb2NhbF9jYW5kaWRhdGVfaWQYAiACKAkSGwoTcmVtb3RlX2NhbmRpZGF0", - "ZV9pZBgDIAIoCRIzCgVzdGF0ZRgEIAEoDjIkLmxpdmVraXQucHJvdG8uSWNl", - "Q2FuZGlkYXRlUGFpclN0YXRlEhEKCW5vbWluYXRlZBgFIAIoCBIUCgxwYWNr", - "ZXRzX3NlbnQYBiACKAQSGAoQcGFja2V0c19yZWNlaXZlZBgHIAIoBBISCgpi", - "eXRlc19zZW50GAggAigEEhYKDmJ5dGVzX3JlY2VpdmVkGAkgAigEEiIKGmxh", - "c3RfcGFja2V0X3NlbnRfdGltZXN0YW1wGAogAigBEiYKHmxhc3RfcGFja2V0", - "X3JlY2VpdmVkX3RpbWVzdGFtcBgLIAIoARIdChV0b3RhbF9yb3VuZF90cmlw", - "X3RpbWUYDCACKAESHwoXY3VycmVudF9yb3VuZF90cmlwX3RpbWUYDSACKAES", - "IgoaYXZhaWxhYmxlX291dGdvaW5nX2JpdHJhdGUYDiACKAESIgoaYXZhaWxh", - "YmxlX2luY29taW5nX2JpdHJhdGUYDyACKAESGQoRcmVxdWVzdHNfcmVjZWl2", - "ZWQYECACKAQSFQoNcmVxdWVzdHNfc2VudBgRIAIoBBIaChJyZXNwb25zZXNf", - "cmVjZWl2ZWQYEiACKAQSFgoOcmVzcG9uc2VzX3NlbnQYEyACKAQSHQoVY29u", - "c2VudF9yZXF1ZXN0c19zZW50GBQgAigEEiEKGXBhY2tldHNfZGlzY2FyZGVk", - "X29uX3NlbmQYFSACKA0SHwoXYnl0ZXNfZGlzY2FyZGVkX29uX3NlbmQYFiAC", - "KAQiiQMKEUljZUNhbmRpZGF0ZVN0YXRzEhQKDHRyYW5zcG9ydF9pZBgBIAIo", - "CRIPCgdhZGRyZXNzGAIgAigJEgwKBHBvcnQYAyACKAUSEAoIcHJvdG9jb2wY", - "BCACKAkSNwoOY2FuZGlkYXRlX3R5cGUYBSABKA4yHy5saXZla2l0LnByb3Rv", - "LkljZUNhbmRpZGF0ZVR5cGUSEAoIcHJpb3JpdHkYBiACKAUSCwoDdXJsGAcg", - "AigJEkEKDnJlbGF5X3Byb3RvY29sGAggASgOMikubGl2ZWtpdC5wcm90by5J", - "Y2VTZXJ2ZXJUcmFuc3BvcnRQcm90b2NvbBISCgpmb3VuZGF0aW9uGAkgAigJ", - "EhcKD3JlbGF0ZWRfYWRkcmVzcxgKIAIoCRIUCgxyZWxhdGVkX3BvcnQYCyAC", - "KAUSGQoRdXNlcm5hbWVfZnJhZ21lbnQYDCACKAkSNAoIdGNwX3R5cGUYDSAB", - "KA4yIi5saXZla2l0LnByb3RvLkljZVRjcENhbmRpZGF0ZVR5cGUigQEKEENl", - "cnRpZmljYXRlU3RhdHMSEwoLZmluZ2VycHJpbnQYASACKAkSHQoVZmluZ2Vy", - "cHJpbnRfYWxnb3JpdGhtGAIgAigJEhoKEmJhc2U2NF9jZXJ0aWZpY2F0ZRgD", - "IAIoCRIdChVpc3N1ZXJfY2VydGlmaWNhdGVfaWQYBCACKAkqUQoQRGF0YUNo", - "YW5uZWxTdGF0ZRIRCg1EQ19DT05ORUNUSU5HEAASCwoHRENfT1BFThABEg4K", - "CkRDX0NMT1NJTkcQAhINCglEQ19DTE9TRUQQAypyChdRdWFsaXR5TGltaXRh", - "dGlvblJlYXNvbhITCg9MSU1JVEFUSU9OX05PTkUQABISCg5MSU1JVEFUSU9O", - "X0NQVRABEhgKFExJTUlUQVRJT05fQkFORFdJRFRIEAISFAoQTElNSVRBVElP", - "Tl9PVEhFUhADKkMKB0ljZVJvbGUSDwoLSUNFX1VOS05PV04QABITCg9JQ0Vf", - "Q09OVFJPTExJTkcQARISCg5JQ0VfQ09OVFJPTExFRBACKp8BChJEdGxzVHJh", - "bnNwb3J0U3RhdGUSFgoSRFRMU19UUkFOU1BPUlRfTkVXEAASHQoZRFRMU19U", - "UkFOU1BPUlRfQ09OTkVDVElORxABEhwKGERUTFNfVFJBTlNQT1JUX0NPTk5F", - "Q1RFRBACEhkKFURUTFNfVFJBTlNQT1JUX0NMT1NFRBADEhkKFURUTFNfVFJB", - "TlNQT1JUX0ZBSUxFRBAEKtQBChFJY2VUcmFuc3BvcnRTdGF0ZRIVChFJQ0Vf", - "VFJBTlNQT1JUX05FVxAAEhoKFklDRV9UUkFOU1BPUlRfQ0hFQ0tJTkcQARIb", - "ChdJQ0VfVFJBTlNQT1JUX0NPTk5FQ1RFRBACEhsKF0lDRV9UUkFOU1BPUlRf", - "Q09NUExFVEVEEAMSHgoaSUNFX1RSQU5TUE9SVF9ESVNDT05ORUNURUQQBBIY", - "ChRJQ0VfVFJBTlNQT1JUX0ZBSUxFRBAFEhgKFElDRV9UUkFOU1BPUlRfQ0xP", - "U0VEEAYqPgoIRHRsc1JvbGUSDwoLRFRMU19DTElFTlQQABIPCgtEVExTX1NF", - "UlZFUhABEhAKDERUTFNfVU5LTk9XThACKnUKFUljZUNhbmRpZGF0ZVBhaXJT", - "dGF0ZRIPCgtQQUlSX0ZST1pFThAAEhAKDFBBSVJfV0FJVElORxABEhQKEFBB", - "SVJfSU5fUFJPR1JFU1MQAhIPCgtQQUlSX0ZBSUxFRBADEhIKDlBBSVJfU1VD", - "Q0VFREVEEAQqPQoQSWNlQ2FuZGlkYXRlVHlwZRIICgRIT1NUEAASCQoFU1JG", - "TFgQARIJCgVQUkZMWBACEgkKBVJFTEFZEAMqVQoaSWNlU2VydmVyVHJhbnNw", - "b3J0UHJvdG9jb2wSEQoNVFJBTlNQT1JUX1VEUBAAEhEKDVRSQU5TUE9SVF9U", - "Q1AQARIRCg1UUkFOU1BPUlRfVExTEAIqVAoTSWNlVGNwQ2FuZGlkYXRlVHlw", - "ZRIUChBDQU5ESURBVEVfQUNUSVZFEAASFQoRQ0FORElEQVRFX1BBU1NJVkUQ", - "ARIQCgxDQU5ESURBVEVfU08QAkIQqgINTGl2ZUtpdC5Qcm90bw==")); + "by5SdGNTdGF0cy5DZXJ0aWZpY2F0ZUgAEjAKBnN0cmVhbRgRIAEoCzIeLmxp", + "dmVraXQucHJvdG8uUnRjU3RhdHMuU3RyZWFtSAASLgoFdHJhY2sYEiABKAsy", + "HS5saXZla2l0LnByb3RvLlJ0Y1N0YXRzLlRyYWNrSAAaWwoFQ29kZWMSKAoD", + "cnRjGAEgAigLMhsubGl2ZWtpdC5wcm90by5SdGNTdGF0c0RhdGESKAoFY29k", + "ZWMYAiACKAsyGS5saXZla2l0LnByb3RvLkNvZGVjU3RhdHMa1QEKCkluYm91", + "bmRSdHASKAoDcnRjGAEgAigLMhsubGl2ZWtpdC5wcm90by5SdGNTdGF0c0Rh", + "dGESLQoGc3RyZWFtGAIgAigLMh0ubGl2ZWtpdC5wcm90by5SdHBTdHJlYW1T", + "dGF0cxI3CghyZWNlaXZlZBgDIAIoCzIlLmxpdmVraXQucHJvdG8uUmVjZWl2", + "ZWRSdHBTdHJlYW1TdGF0cxI1CgdpbmJvdW5kGAQgAigLMiQubGl2ZWtpdC5w", + "cm90by5JbmJvdW5kUnRwU3RyZWFtU3RhdHMa0AEKC091dGJvdW5kUnRwEigK", + "A3J0YxgBIAIoCzIbLmxpdmVraXQucHJvdG8uUnRjU3RhdHNEYXRhEi0KBnN0", + "cmVhbRgCIAIoCzIdLmxpdmVraXQucHJvdG8uUnRwU3RyZWFtU3RhdHMSLwoE", + "c2VudBgDIAIoCzIhLmxpdmVraXQucHJvdG8uU2VudFJ0cFN0cmVhbVN0YXRz", + "EjcKCG91dGJvdW5kGAQgAigLMiUubGl2ZWtpdC5wcm90by5PdXRib3VuZFJ0", + "cFN0cmVhbVN0YXRzGugBChBSZW1vdGVJbmJvdW5kUnRwEigKA3J0YxgBIAIo", + "CzIbLmxpdmVraXQucHJvdG8uUnRjU3RhdHNEYXRhEi0KBnN0cmVhbRgCIAIo", + "CzIdLmxpdmVraXQucHJvdG8uUnRwU3RyZWFtU3RhdHMSNwoIcmVjZWl2ZWQY", + "AyACKAsyJS5saXZla2l0LnByb3RvLlJlY2VpdmVkUnRwU3RyZWFtU3RhdHMS", + "QgoOcmVtb3RlX2luYm91bmQYBCACKAsyKi5saXZla2l0LnByb3RvLlJlbW90", + "ZUluYm91bmRSdHBTdHJlYW1TdGF0cxrjAQoRUmVtb3RlT3V0Ym91bmRSdHAS", + "KAoDcnRjGAEgAigLMhsubGl2ZWtpdC5wcm90by5SdGNTdGF0c0RhdGESLQoG", + "c3RyZWFtGAIgAigLMh0ubGl2ZWtpdC5wcm90by5SdHBTdHJlYW1TdGF0cxIv", + "CgRzZW50GAMgAigLMiEubGl2ZWtpdC5wcm90by5TZW50UnRwU3RyZWFtU3Rh", + "dHMSRAoPcmVtb3RlX291dGJvdW5kGAQgAigLMisubGl2ZWtpdC5wcm90by5S", + "ZW1vdGVPdXRib3VuZFJ0cFN0cmVhbVN0YXRzGsgBCgtNZWRpYVNvdXJjZRIo", + "CgNydGMYASACKAsyGy5saXZla2l0LnByb3RvLlJ0Y1N0YXRzRGF0YRIvCgZz", + "b3VyY2UYAiACKAsyHy5saXZla2l0LnByb3RvLk1lZGlhU291cmNlU3RhdHMS", + "LgoFYXVkaW8YAyACKAsyHy5saXZla2l0LnByb3RvLkF1ZGlvU291cmNlU3Rh", + "dHMSLgoFdmlkZW8YBCACKAsyHy5saXZla2l0LnByb3RvLlZpZGVvU291cmNl", + "U3RhdHMacQoMTWVkaWFQbGF5b3V0EigKA3J0YxgBIAIoCzIbLmxpdmVraXQu", + "cHJvdG8uUnRjU3RhdHNEYXRhEjcKDWF1ZGlvX3BsYXlvdXQYAiACKAsyIC5s", + "aXZla2l0LnByb3RvLkF1ZGlvUGxheW91dFN0YXRzGmoKDlBlZXJDb25uZWN0", + "aW9uEigKA3J0YxgBIAIoCzIbLmxpdmVraXQucHJvdG8uUnRjU3RhdHNEYXRh", + "Ei4KAnBjGAIgAigLMiIubGl2ZWtpdC5wcm90by5QZWVyQ29ubmVjdGlvblN0", + "YXRzGmQKC0RhdGFDaGFubmVsEigKA3J0YxgBIAIoCzIbLmxpdmVraXQucHJv", + "dG8uUnRjU3RhdHNEYXRhEisKAmRjGAIgAigLMh8ubGl2ZWtpdC5wcm90by5E", + "YXRhQ2hhbm5lbFN0YXRzGmcKCVRyYW5zcG9ydBIoCgNydGMYASACKAsyGy5s", + "aXZla2l0LnByb3RvLlJ0Y1N0YXRzRGF0YRIwCgl0cmFuc3BvcnQYAiACKAsy", + "HS5saXZla2l0LnByb3RvLlRyYW5zcG9ydFN0YXRzGnQKDUNhbmRpZGF0ZVBh", + "aXISKAoDcnRjGAEgAigLMhsubGl2ZWtpdC5wcm90by5SdGNTdGF0c0RhdGES", + "OQoOY2FuZGlkYXRlX3BhaXIYAiACKAsyIS5saXZla2l0LnByb3RvLkNhbmRp", + "ZGF0ZVBhaXJTdGF0cxpvCg5Mb2NhbENhbmRpZGF0ZRIoCgNydGMYASACKAsy", + "Gy5saXZla2l0LnByb3RvLlJ0Y1N0YXRzRGF0YRIzCgljYW5kaWRhdGUYAiAC", + "KAsyIC5saXZla2l0LnByb3RvLkljZUNhbmRpZGF0ZVN0YXRzGnAKD1JlbW90", + "ZUNhbmRpZGF0ZRIoCgNydGMYASACKAsyGy5saXZla2l0LnByb3RvLlJ0Y1N0", + "YXRzRGF0YRIzCgljYW5kaWRhdGUYAiACKAsyIC5saXZla2l0LnByb3RvLklj", + "ZUNhbmRpZGF0ZVN0YXRzGm0KC0NlcnRpZmljYXRlEigKA3J0YxgBIAIoCzIb", + "LmxpdmVraXQucHJvdG8uUnRjU3RhdHNEYXRhEjQKC2NlcnRpZmljYXRlGAIg", + "AigLMh8ubGl2ZWtpdC5wcm90by5DZXJ0aWZpY2F0ZVN0YXRzGl4KBlN0cmVh", + "bRIoCgNydGMYASACKAsyGy5saXZla2l0LnByb3RvLlJ0Y1N0YXRzRGF0YRIq", + "CgZzdHJlYW0YAiACKAsyGi5saXZla2l0LnByb3RvLlN0cmVhbVN0YXRzGgcK", + "BVRyYWNrQgcKBXN0YXRzIi0KDFJ0Y1N0YXRzRGF0YRIKCgJpZBgBIAIoCRIR", + "Cgl0aW1lc3RhbXAYAiACKAMiiAEKCkNvZGVjU3RhdHMSFAoMcGF5bG9hZF90", + "eXBlGAEgAigNEhQKDHRyYW5zcG9ydF9pZBgCIAIoCRIRCgltaW1lX3R5cGUY", + "AyACKAkSEgoKY2xvY2tfcmF0ZRgEIAIoDRIQCghjaGFubmVscxgFIAIoDRIV", + "Cg1zZHBfZm10cF9saW5lGAYgAigJIlQKDlJ0cFN0cmVhbVN0YXRzEgwKBHNz", + "cmMYASACKA0SDAoEa2luZBgCIAIoCRIUCgx0cmFuc3BvcnRfaWQYAyACKAkS", + "EAoIY29kZWNfaWQYBCACKAkiWAoWUmVjZWl2ZWRSdHBTdHJlYW1TdGF0cxIY", + "ChBwYWNrZXRzX3JlY2VpdmVkGAEgAigEEhQKDHBhY2tldHNfbG9zdBgCIAIo", + "AxIOCgZqaXR0ZXIYAyACKAEiggwKFUluYm91bmRSdHBTdHJlYW1TdGF0cxIY", + "ChB0cmFja19pZGVudGlmaWVyGAEgAigJEgsKA21pZBgCIAIoCRIRCglyZW1v", + "dGVfaWQYAyACKAkSFgoOZnJhbWVzX2RlY29kZWQYBCACKA0SGgoSa2V5X2Zy", + "YW1lc19kZWNvZGVkGAUgAigNEhcKD2ZyYW1lc19yZW5kZXJlZBgGIAIoDRIW", + "Cg5mcmFtZXNfZHJvcHBlZBgHIAIoDRITCgtmcmFtZV93aWR0aBgIIAIoDRIU", + "CgxmcmFtZV9oZWlnaHQYCSACKA0SGQoRZnJhbWVzX3Blcl9zZWNvbmQYCiAC", + "KAESDgoGcXBfc3VtGAsgAigEEhkKEXRvdGFsX2RlY29kZV90aW1lGAwgAigB", + "Eh8KF3RvdGFsX2ludGVyX2ZyYW1lX2RlbGF5GA0gAigBEicKH3RvdGFsX3Nx", + "dWFyZWRfaW50ZXJfZnJhbWVfZGVsYXkYDiACKAESEwoLcGF1c2VfY291bnQY", + "DyACKA0SHAoUdG90YWxfcGF1c2VfZHVyYXRpb24YECACKAESFAoMZnJlZXpl", + "X2NvdW50GBEgAigNEh0KFXRvdGFsX2ZyZWV6ZV9kdXJhdGlvbhgSIAIoARIm", + "Ch5sYXN0X3BhY2tldF9yZWNlaXZlZF90aW1lc3RhbXAYEyACKAESHQoVaGVh", + "ZGVyX2J5dGVzX3JlY2VpdmVkGBQgAigEEhkKEXBhY2tldHNfZGlzY2FyZGVk", + "GBUgAigEEhoKEmZlY19ieXRlc19yZWNlaXZlZBgWIAIoBBIcChRmZWNfcGFj", + "a2V0c19yZWNlaXZlZBgXIAIoBBIdChVmZWNfcGFja2V0c19kaXNjYXJkZWQY", + "GCACKAQSFgoOYnl0ZXNfcmVjZWl2ZWQYGSACKAQSEgoKbmFja19jb3VudBga", + "IAIoDRIRCglmaXJfY291bnQYGyACKA0SEQoJcGxpX2NvdW50GBwgAigNEh4K", + "FnRvdGFsX3Byb2Nlc3NpbmdfZGVsYXkYHSACKAESIwobZXN0aW1hdGVkX3Bs", + "YXlvdXRfdGltZXN0YW1wGB4gAigBEhsKE2ppdHRlcl9idWZmZXJfZGVsYXkY", + "HyACKAESIgoaaml0dGVyX2J1ZmZlcl90YXJnZXRfZGVsYXkYICACKAESIwob", + "aml0dGVyX2J1ZmZlcl9lbWl0dGVkX2NvdW50GCEgAigEEiMKG2ppdHRlcl9i", + "dWZmZXJfbWluaW11bV9kZWxheRgiIAIoARIeChZ0b3RhbF9zYW1wbGVzX3Jl", + "Y2VpdmVkGCMgAigEEhkKEWNvbmNlYWxlZF9zYW1wbGVzGCQgAigEEiAKGHNp", + "bGVudF9jb25jZWFsZWRfc2FtcGxlcxglIAIoBBIaChJjb25jZWFsbWVudF9l", + "dmVudHMYJiACKAQSKQohaW5zZXJ0ZWRfc2FtcGxlc19mb3JfZGVjZWxlcmF0", + "aW9uGCcgAigEEigKIHJlbW92ZWRfc2FtcGxlc19mb3JfYWNjZWxlcmF0aW9u", + "GCggAigEEhMKC2F1ZGlvX2xldmVsGCkgAigBEhoKEnRvdGFsX2F1ZGlvX2Vu", + "ZXJneRgqIAIoARIeChZ0b3RhbF9zYW1wbGVzX2R1cmF0aW9uGCsgAigBEhcK", + "D2ZyYW1lc19yZWNlaXZlZBgsIAIoBBIeChZkZWNvZGVyX2ltcGxlbWVudGF0", + "aW9uGC0gAigJEhIKCnBsYXlvdXRfaWQYLiACKAkSHwoXcG93ZXJfZWZmaWNp", + "ZW50X2RlY29kZXIYLyACKAgSLgomZnJhbWVzX2Fzc2VtYmxlZF9mcm9tX211", + "bHRpcGxlX3BhY2tldHMYMCACKAQSGwoTdG90YWxfYXNzZW1ibHlfdGltZRgx", + "IAIoARImCh5yZXRyYW5zbWl0dGVkX3BhY2tldHNfcmVjZWl2ZWQYMiACKAQS", + "JAoccmV0cmFuc21pdHRlZF9ieXRlc19yZWNlaXZlZBgzIAIoBBIQCghydHhf", + "c3NyYxg0IAIoDRIQCghmZWNfc3NyYxg1IAIoDSI+ChJTZW50UnRwU3RyZWFt", + "U3RhdHMSFAoMcGFja2V0c19zZW50GAEgAigEEhIKCmJ5dGVzX3NlbnQYAiAC", + "KAQi0QcKFk91dGJvdW5kUnRwU3RyZWFtU3RhdHMSCwoDbWlkGAEgAigJEhcK", + "D21lZGlhX3NvdXJjZV9pZBgCIAIoCRIRCglyZW1vdGVfaWQYAyACKAkSCwoD", + "cmlkGAQgAigJEhkKEWhlYWRlcl9ieXRlc19zZW50GAUgAigEEiIKGnJldHJh", + "bnNtaXR0ZWRfcGFja2V0c19zZW50GAYgAigEEiAKGHJldHJhbnNtaXR0ZWRf", + "Ynl0ZXNfc2VudBgHIAIoBBIQCghydHhfc3NyYxgIIAIoDRIWCg50YXJnZXRf", + "Yml0cmF0ZRgJIAIoARIiChp0b3RhbF9lbmNvZGVkX2J5dGVzX3RhcmdldBgK", + "IAIoBBITCgtmcmFtZV93aWR0aBgLIAIoDRIUCgxmcmFtZV9oZWlnaHQYDCAC", + "KA0SGQoRZnJhbWVzX3Blcl9zZWNvbmQYDSACKAESEwoLZnJhbWVzX3NlbnQY", + "DiACKA0SGAoQaHVnZV9mcmFtZXNfc2VudBgPIAIoDRIWCg5mcmFtZXNfZW5j", + "b2RlZBgQIAIoDRIaChJrZXlfZnJhbWVzX2VuY29kZWQYESACKA0SDgoGcXBf", + "c3VtGBIgAigEEhkKEXRvdGFsX2VuY29kZV90aW1lGBMgAigBEh8KF3RvdGFs", + "X3BhY2tldF9zZW5kX2RlbGF5GBQgAigBEkkKGXF1YWxpdHlfbGltaXRhdGlv", + "bl9yZWFzb24YFSACKA4yJi5saXZla2l0LnByb3RvLlF1YWxpdHlMaW1pdGF0", + "aW9uUmVhc29uEmsKHHF1YWxpdHlfbGltaXRhdGlvbl9kdXJhdGlvbnMYFiAD", + "KAsyRS5saXZla2l0LnByb3RvLk91dGJvdW5kUnRwU3RyZWFtU3RhdHMuUXVh", + "bGl0eUxpbWl0YXRpb25EdXJhdGlvbnNFbnRyeRItCiVxdWFsaXR5X2xpbWl0", + "YXRpb25fcmVzb2x1dGlvbl9jaGFuZ2VzGBcgAigNEhIKCm5hY2tfY291bnQY", + "GCACKA0SEQoJZmlyX2NvdW50GBkgAigNEhEKCXBsaV9jb3VudBgaIAIoDRIe", + "ChZlbmNvZGVyX2ltcGxlbWVudGF0aW9uGBsgAigJEh8KF3Bvd2VyX2VmZmlj", + "aWVudF9lbmNvZGVyGBwgAigIEg4KBmFjdGl2ZRgdIAIoCBIYChBzY2FsYWJp", + "bGl0eV9tb2RlGB4gAigJGkEKH1F1YWxpdHlMaW1pdGF0aW9uRHVyYXRpb25z", + "RW50cnkSCwoDa2V5GAEgASgJEg0KBXZhbHVlGAIgASgBOgI4ASKkAQobUmVt", + "b3RlSW5ib3VuZFJ0cFN0cmVhbVN0YXRzEhAKCGxvY2FsX2lkGAEgAigJEhcK", + "D3JvdW5kX3RyaXBfdGltZRgCIAIoARIdChV0b3RhbF9yb3VuZF90cmlwX3Rp", + "bWUYAyACKAESFQoNZnJhY3Rpb25fbG9zdBgEIAIoARIkChxyb3VuZF90cmlw", + "X3RpbWVfbWVhc3VyZW1lbnRzGAUgAigEIr4BChxSZW1vdGVPdXRib3VuZFJ0", + "cFN0cmVhbVN0YXRzEhAKCGxvY2FsX2lkGAEgAigJEhgKEHJlbW90ZV90aW1l", + "c3RhbXAYAiACKAESFAoMcmVwb3J0c19zZW50GAMgAigEEhcKD3JvdW5kX3Ry", + "aXBfdGltZRgEIAIoARIdChV0b3RhbF9yb3VuZF90cmlwX3RpbWUYBSACKAES", + "JAoccm91bmRfdHJpcF90aW1lX21lYXN1cmVtZW50cxgGIAIoBCI6ChBNZWRp", + "YVNvdXJjZVN0YXRzEhgKEHRyYWNrX2lkZW50aWZpZXIYASACKAkSDAoEa2lu", + "ZBgCIAIoCSKiAgoQQXVkaW9Tb3VyY2VTdGF0cxITCgthdWRpb19sZXZlbBgB", + "IAIoARIaChJ0b3RhbF9hdWRpb19lbmVyZ3kYAiACKAESHgoWdG90YWxfc2Ft", + "cGxlc19kdXJhdGlvbhgDIAIoARIYChBlY2hvX3JldHVybl9sb3NzGAQgAigB", + "EiQKHGVjaG9fcmV0dXJuX2xvc3NfZW5oYW5jZW1lbnQYBSACKAESIAoYZHJv", + "cHBlZF9zYW1wbGVzX2R1cmF0aW9uGAYgAigBEh4KFmRyb3BwZWRfc2FtcGxl", + "c19ldmVudHMYByACKA0SGwoTdG90YWxfY2FwdHVyZV9kZWxheRgIIAIoARIe", + "ChZ0b3RhbF9zYW1wbGVzX2NhcHR1cmVkGAkgAigEIlwKEFZpZGVvU291cmNl", + "U3RhdHMSDQoFd2lkdGgYASACKA0SDgoGaGVpZ2h0GAIgAigNEg4KBmZyYW1l", + "cxgDIAIoDRIZChFmcmFtZXNfcGVyX3NlY29uZBgEIAIoASLFAQoRQXVkaW9Q", + "bGF5b3V0U3RhdHMSDAoEa2luZBgBIAIoCRIkChxzeW50aGVzaXplZF9zYW1w", + "bGVzX2R1cmF0aW9uGAIgAigBEiIKGnN5bnRoZXNpemVkX3NhbXBsZXNfZXZl", + "bnRzGAMgAigNEh4KFnRvdGFsX3NhbXBsZXNfZHVyYXRpb24YBCACKAESGwoT", + "dG90YWxfcGxheW91dF9kZWxheRgFIAIoARIbChN0b3RhbF9zYW1wbGVzX2Nv", + "dW50GAYgAigEIlEKE1BlZXJDb25uZWN0aW9uU3RhdHMSHAoUZGF0YV9jaGFu", + "bmVsc19vcGVuZWQYASACKA0SHAoUZGF0YV9jaGFubmVsc19jbG9zZWQYAiAC", + "KA0i4gEKEERhdGFDaGFubmVsU3RhdHMSDQoFbGFiZWwYASACKAkSEAoIcHJv", + "dG9jb2wYAiACKAkSHwoXZGF0YV9jaGFubmVsX2lkZW50aWZpZXIYAyACKAUS", + "LgoFc3RhdGUYBCABKA4yHy5saXZla2l0LnByb3RvLkRhdGFDaGFubmVsU3Rh", + "dGUSFQoNbWVzc2FnZXNfc2VudBgFIAIoDRISCgpieXRlc19zZW50GAYgAigE", + "EhkKEW1lc3NhZ2VzX3JlY2VpdmVkGAcgAigNEhYKDmJ5dGVzX3JlY2VpdmVk", + "GAggAigEIpwECg5UcmFuc3BvcnRTdGF0cxIUCgxwYWNrZXRzX3NlbnQYASAC", + "KAQSGAoQcGFja2V0c19yZWNlaXZlZBgCIAIoBBISCgpieXRlc19zZW50GAMg", + "AigEEhYKDmJ5dGVzX3JlY2VpdmVkGAQgAigEEigKCGljZV9yb2xlGAUgAigO", + "MhYubGl2ZWtpdC5wcm90by5JY2VSb2xlEiMKG2ljZV9sb2NhbF91c2VybmFt", + "ZV9mcmFnbWVudBgGIAIoCRI1CgpkdGxzX3N0YXRlGAcgASgOMiEubGl2ZWtp", + "dC5wcm90by5EdGxzVHJhbnNwb3J0U3RhdGUSMwoJaWNlX3N0YXRlGAggASgO", + "MiAubGl2ZWtpdC5wcm90by5JY2VUcmFuc3BvcnRTdGF0ZRIiChpzZWxlY3Rl", + "ZF9jYW5kaWRhdGVfcGFpcl9pZBgJIAIoCRIcChRsb2NhbF9jZXJ0aWZpY2F0", + "ZV9pZBgKIAIoCRIdChVyZW1vdGVfY2VydGlmaWNhdGVfaWQYCyACKAkSEwoL", + "dGxzX3ZlcnNpb24YDCACKAkSEwoLZHRsc19jaXBoZXIYDSACKAkSKgoJZHRs", + "c19yb2xlGA4gAigOMhcubGl2ZWtpdC5wcm90by5EdGxzUm9sZRITCgtzcnRw", + "X2NpcGhlchgPIAIoCRInCh9zZWxlY3RlZF9jYW5kaWRhdGVfcGFpcl9jaGFu", + "Z2VzGBAgAigNIqQFChJDYW5kaWRhdGVQYWlyU3RhdHMSFAoMdHJhbnNwb3J0", + "X2lkGAEgAigJEhoKEmxvY2FsX2NhbmRpZGF0ZV9pZBgCIAIoCRIbChNyZW1v", + "dGVfY2FuZGlkYXRlX2lkGAMgAigJEjMKBXN0YXRlGAQgASgOMiQubGl2ZWtp", + "dC5wcm90by5JY2VDYW5kaWRhdGVQYWlyU3RhdGUSEQoJbm9taW5hdGVkGAUg", + "AigIEhQKDHBhY2tldHNfc2VudBgGIAIoBBIYChBwYWNrZXRzX3JlY2VpdmVk", + "GAcgAigEEhIKCmJ5dGVzX3NlbnQYCCACKAQSFgoOYnl0ZXNfcmVjZWl2ZWQY", + "CSACKAQSIgoabGFzdF9wYWNrZXRfc2VudF90aW1lc3RhbXAYCiACKAESJgoe", + "bGFzdF9wYWNrZXRfcmVjZWl2ZWRfdGltZXN0YW1wGAsgAigBEh0KFXRvdGFs", + "X3JvdW5kX3RyaXBfdGltZRgMIAIoARIfChdjdXJyZW50X3JvdW5kX3RyaXBf", + "dGltZRgNIAIoARIiChphdmFpbGFibGVfb3V0Z29pbmdfYml0cmF0ZRgOIAIo", + "ARIiChphdmFpbGFibGVfaW5jb21pbmdfYml0cmF0ZRgPIAIoARIZChFyZXF1", + "ZXN0c19yZWNlaXZlZBgQIAIoBBIVCg1yZXF1ZXN0c19zZW50GBEgAigEEhoK", + "EnJlc3BvbnNlc19yZWNlaXZlZBgSIAIoBBIWCg5yZXNwb25zZXNfc2VudBgT", + "IAIoBBIdChVjb25zZW50X3JlcXVlc3RzX3NlbnQYFCACKAQSIQoZcGFja2V0", + "c19kaXNjYXJkZWRfb25fc2VuZBgVIAIoDRIfChdieXRlc19kaXNjYXJkZWRf", + "b25fc2VuZBgWIAIoBCKJAwoRSWNlQ2FuZGlkYXRlU3RhdHMSFAoMdHJhbnNw", + "b3J0X2lkGAEgAigJEg8KB2FkZHJlc3MYAiACKAkSDAoEcG9ydBgDIAIoBRIQ", + "Cghwcm90b2NvbBgEIAIoCRI3Cg5jYW5kaWRhdGVfdHlwZRgFIAEoDjIfLmxp", + "dmVraXQucHJvdG8uSWNlQ2FuZGlkYXRlVHlwZRIQCghwcmlvcml0eRgGIAIo", + "BRILCgN1cmwYByACKAkSQQoOcmVsYXlfcHJvdG9jb2wYCCABKA4yKS5saXZl", + "a2l0LnByb3RvLkljZVNlcnZlclRyYW5zcG9ydFByb3RvY29sEhIKCmZvdW5k", + "YXRpb24YCSACKAkSFwoPcmVsYXRlZF9hZGRyZXNzGAogAigJEhQKDHJlbGF0", + "ZWRfcG9ydBgLIAIoBRIZChF1c2VybmFtZV9mcmFnbWVudBgMIAIoCRI0Cgh0", + "Y3BfdHlwZRgNIAEoDjIiLmxpdmVraXQucHJvdG8uSWNlVGNwQ2FuZGlkYXRl", + "VHlwZSKBAQoQQ2VydGlmaWNhdGVTdGF0cxITCgtmaW5nZXJwcmludBgBIAIo", + "CRIdChVmaW5nZXJwcmludF9hbGdvcml0aG0YAiACKAkSGgoSYmFzZTY0X2Nl", + "cnRpZmljYXRlGAMgAigJEh0KFWlzc3Vlcl9jZXJ0aWZpY2F0ZV9pZBgEIAIo", + "CSI0CgtTdHJlYW1TdGF0cxIKCgJpZBgBIAIoCRIZChFzdHJlYW1faWRlbnRp", + "ZmllchgCIAIoCSpRChBEYXRhQ2hhbm5lbFN0YXRlEhEKDURDX0NPTk5FQ1RJ", + "TkcQABILCgdEQ19PUEVOEAESDgoKRENfQ0xPU0lORxACEg0KCURDX0NMT1NF", + "RBADKnIKF1F1YWxpdHlMaW1pdGF0aW9uUmVhc29uEhMKD0xJTUlUQVRJT05f", + "Tk9ORRAAEhIKDkxJTUlUQVRJT05fQ1BVEAESGAoUTElNSVRBVElPTl9CQU5E", + "V0lEVEgQAhIUChBMSU1JVEFUSU9OX09USEVSEAMqQwoHSWNlUm9sZRIPCgtJ", + "Q0VfVU5LTk9XThAAEhMKD0lDRV9DT05UUk9MTElORxABEhIKDklDRV9DT05U", + "Uk9MTEVEEAIqnwEKEkR0bHNUcmFuc3BvcnRTdGF0ZRIWChJEVExTX1RSQU5T", + "UE9SVF9ORVcQABIdChlEVExTX1RSQU5TUE9SVF9DT05ORUNUSU5HEAESHAoY", + "RFRMU19UUkFOU1BPUlRfQ09OTkVDVEVEEAISGQoVRFRMU19UUkFOU1BPUlRf", + "Q0xPU0VEEAMSGQoVRFRMU19UUkFOU1BPUlRfRkFJTEVEEAQq1AEKEUljZVRy", + "YW5zcG9ydFN0YXRlEhUKEUlDRV9UUkFOU1BPUlRfTkVXEAASGgoWSUNFX1RS", + "QU5TUE9SVF9DSEVDS0lORxABEhsKF0lDRV9UUkFOU1BPUlRfQ09OTkVDVEVE", + "EAISGwoXSUNFX1RSQU5TUE9SVF9DT01QTEVURUQQAxIeChpJQ0VfVFJBTlNQ", + "T1JUX0RJU0NPTk5FQ1RFRBAEEhgKFElDRV9UUkFOU1BPUlRfRkFJTEVEEAUS", + "GAoUSUNFX1RSQU5TUE9SVF9DTE9TRUQQBio+CghEdGxzUm9sZRIPCgtEVExT", + "X0NMSUVOVBAAEg8KC0RUTFNfU0VSVkVSEAESEAoMRFRMU19VTktOT1dOEAIq", + "dQoVSWNlQ2FuZGlkYXRlUGFpclN0YXRlEg8KC1BBSVJfRlJPWkVOEAASEAoM", + "UEFJUl9XQUlUSU5HEAESFAoQUEFJUl9JTl9QUk9HUkVTUxACEg8KC1BBSVJf", + "RkFJTEVEEAMSEgoOUEFJUl9TVUNDRUVERUQQBCo9ChBJY2VDYW5kaWRhdGVU", + "eXBlEggKBEhPU1QQABIJCgVTUkZMWBABEgkKBVBSRkxYEAISCQoFUkVMQVkQ", + "AypVChpJY2VTZXJ2ZXJUcmFuc3BvcnRQcm90b2NvbBIRCg1UUkFOU1BPUlRf", + "VURQEAASEQoNVFJBTlNQT1JUX1RDUBABEhEKDVRSQU5TUE9SVF9UTFMQAipU", + "ChNJY2VUY3BDYW5kaWRhdGVUeXBlEhQKEENBTkRJREFURV9BQ1RJVkUQABIV", + "ChFDQU5ESURBVEVfUEFTU0lWRRABEhAKDENBTkRJREFURV9TTxACQhCqAg1M", + "aXZlS2l0LlByb3Rv")); descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData, new pbr::FileDescriptor[] { }, new pbr::GeneratedClrTypeInfo(new[] {typeof(global::LiveKit.Proto.DataChannelState), typeof(global::LiveKit.Proto.QualityLimitationReason), typeof(global::LiveKit.Proto.IceRole), typeof(global::LiveKit.Proto.DtlsTransportState), typeof(global::LiveKit.Proto.IceTransportState), typeof(global::LiveKit.Proto.DtlsRole), typeof(global::LiveKit.Proto.IceCandidatePairState), typeof(global::LiveKit.Proto.IceCandidateType), typeof(global::LiveKit.Proto.IceServerTransportProtocol), typeof(global::LiveKit.Proto.IceTcpCandidateType), }, null, new pbr::GeneratedClrTypeInfo[] { - new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.RtcStats), global::LiveKit.Proto.RtcStats.Parser, new[]{ "Codec", "InboundRtp", "OutboundRtp", "RemoteInboundRtp", "RemoteOutboundRtp", "MediaSource", "MediaPlayout", "PeerConnection", "DataChannel", "Transport", "CandidatePair", "LocalCandidate", "RemoteCandidate", "Certificate", "Track" }, new[]{ "Stats" }, null, null, new pbr::GeneratedClrTypeInfo[] { new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.RtcStats.Types.Codec), global::LiveKit.Proto.RtcStats.Types.Codec.Parser, new[]{ "Rtc", "Codec_" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.RtcStats), global::LiveKit.Proto.RtcStats.Parser, new[]{ "Codec", "InboundRtp", "OutboundRtp", "RemoteInboundRtp", "RemoteOutboundRtp", "MediaSource", "MediaPlayout", "PeerConnection", "DataChannel", "Transport", "CandidatePair", "LocalCandidate", "RemoteCandidate", "Certificate", "Stream", "Track" }, new[]{ "Stats" }, null, null, new pbr::GeneratedClrTypeInfo[] { new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.RtcStats.Types.Codec), global::LiveKit.Proto.RtcStats.Types.Codec.Parser, new[]{ "Rtc", "Codec_" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.RtcStats.Types.InboundRtp), global::LiveKit.Proto.RtcStats.Types.InboundRtp.Parser, new[]{ "Rtc", "Stream", "Received", "Inbound" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.RtcStats.Types.OutboundRtp), global::LiveKit.Proto.RtcStats.Types.OutboundRtp.Parser, new[]{ "Rtc", "Stream", "Sent", "Outbound" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.RtcStats.Types.RemoteInboundRtp), global::LiveKit.Proto.RtcStats.Types.RemoteInboundRtp.Parser, new[]{ "Rtc", "Stream", "Received", "RemoteInbound" }, null, null, null, null), @@ -267,6 +272,7 @@ static StatsReflection() { new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.RtcStats.Types.LocalCandidate), global::LiveKit.Proto.RtcStats.Types.LocalCandidate.Parser, new[]{ "Rtc", "Candidate" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.RtcStats.Types.RemoteCandidate), global::LiveKit.Proto.RtcStats.Types.RemoteCandidate.Parser, new[]{ "Rtc", "Candidate" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.RtcStats.Types.Certificate), global::LiveKit.Proto.RtcStats.Types.Certificate.Parser, new[]{ "Rtc", "Certificate_" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.RtcStats.Types.Stream), global::LiveKit.Proto.RtcStats.Types.Stream.Parser, new[]{ "Rtc", "Stream_" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.RtcStats.Types.Track), global::LiveKit.Proto.RtcStats.Types.Track.Parser, null, null, null, null, null)}), new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.RtcStatsData), global::LiveKit.Proto.RtcStatsData.Parser, new[]{ "Id", "Timestamp" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.CodecStats), global::LiveKit.Proto.CodecStats.Parser, new[]{ "PayloadType", "TransportId", "MimeType", "ClockRate", "Channels", "SdpFmtpLine" }, null, null, null, null), @@ -286,7 +292,8 @@ static StatsReflection() { new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.TransportStats), global::LiveKit.Proto.TransportStats.Parser, new[]{ "PacketsSent", "PacketsReceived", "BytesSent", "BytesReceived", "IceRole", "IceLocalUsernameFragment", "DtlsState", "IceState", "SelectedCandidatePairId", "LocalCertificateId", "RemoteCertificateId", "TlsVersion", "DtlsCipher", "DtlsRole", "SrtpCipher", "SelectedCandidatePairChanges" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.CandidatePairStats), global::LiveKit.Proto.CandidatePairStats.Parser, new[]{ "TransportId", "LocalCandidateId", "RemoteCandidateId", "State", "Nominated", "PacketsSent", "PacketsReceived", "BytesSent", "BytesReceived", "LastPacketSentTimestamp", "LastPacketReceivedTimestamp", "TotalRoundTripTime", "CurrentRoundTripTime", "AvailableOutgoingBitrate", "AvailableIncomingBitrate", "RequestsReceived", "RequestsSent", "ResponsesReceived", "ResponsesSent", "ConsentRequestsSent", "PacketsDiscardedOnSend", "BytesDiscardedOnSend" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.IceCandidateStats), global::LiveKit.Proto.IceCandidateStats.Parser, new[]{ "TransportId", "Address", "Port", "Protocol", "CandidateType", "Priority", "Url", "RelayProtocol", "Foundation", "RelatedAddress", "RelatedPort", "UsernameFragment", "TcpType" }, null, null, null, null), - new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.CertificateStats), global::LiveKit.Proto.CertificateStats.Parser, new[]{ "Fingerprint", "FingerprintAlgorithm", "Base64Certificate", "IssuerCertificateId" }, null, null, null, null) + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.CertificateStats), global::LiveKit.Proto.CertificateStats.Parser, new[]{ "Fingerprint", "FingerprintAlgorithm", "Base64Certificate", "IssuerCertificateId" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.StreamStats), global::LiveKit.Proto.StreamStats.Parser, new[]{ "Id", "StreamIdentifier" }, null, null, null, null) })); } #endregion @@ -445,6 +452,9 @@ public RtcStats(RtcStats other) : this() { case StatsOneofCase.Certificate: Certificate = other.Certificate.Clone(); break; + case StatsOneofCase.Stream: + Stream = other.Stream.Clone(); + break; case StatsOneofCase.Track: Track = other.Track.Clone(); break; @@ -627,8 +637,20 @@ public RtcStats Clone() { } } + /// Field number for the "stream" field. + public const int StreamFieldNumber = 17; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.RtcStats.Types.Stream Stream { + get { return statsCase_ == StatsOneofCase.Stream ? (global::LiveKit.Proto.RtcStats.Types.Stream) stats_ : null; } + set { + stats_ = value; + statsCase_ = value == null ? StatsOneofCase.None : StatsOneofCase.Stream; + } + } + /// Field number for the "track" field. - public const int TrackFieldNumber = 17; + public const int TrackFieldNumber = 18; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public global::LiveKit.Proto.RtcStats.Types.Track Track { @@ -657,7 +679,8 @@ public enum StatsOneofCase { LocalCandidate = 14, RemoteCandidate = 15, Certificate = 16, - Track = 17, + Stream = 17, + Track = 18, } private StatsOneofCase statsCase_ = StatsOneofCase.None; [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -702,6 +725,7 @@ public bool Equals(RtcStats other) { if (!object.Equals(LocalCandidate, other.LocalCandidate)) return false; if (!object.Equals(RemoteCandidate, other.RemoteCandidate)) return false; if (!object.Equals(Certificate, other.Certificate)) return false; + if (!object.Equals(Stream, other.Stream)) return false; if (!object.Equals(Track, other.Track)) return false; if (StatsCase != other.StatsCase) return false; return Equals(_unknownFields, other._unknownFields); @@ -725,6 +749,7 @@ public override int GetHashCode() { if (statsCase_ == StatsOneofCase.LocalCandidate) hash ^= LocalCandidate.GetHashCode(); if (statsCase_ == StatsOneofCase.RemoteCandidate) hash ^= RemoteCandidate.GetHashCode(); if (statsCase_ == StatsOneofCase.Certificate) hash ^= Certificate.GetHashCode(); + if (statsCase_ == StatsOneofCase.Stream) hash ^= Stream.GetHashCode(); if (statsCase_ == StatsOneofCase.Track) hash ^= Track.GetHashCode(); hash ^= (int) statsCase_; if (_unknownFields != null) { @@ -801,8 +826,12 @@ public void WriteTo(pb::CodedOutputStream output) { output.WriteRawTag(130, 1); output.WriteMessage(Certificate); } - if (statsCase_ == StatsOneofCase.Track) { + if (statsCase_ == StatsOneofCase.Stream) { output.WriteRawTag(138, 1); + output.WriteMessage(Stream); + } + if (statsCase_ == StatsOneofCase.Track) { + output.WriteRawTag(146, 1); output.WriteMessage(Track); } if (_unknownFields != null) { @@ -871,8 +900,12 @@ public void WriteTo(pb::CodedOutputStream output) { output.WriteRawTag(130, 1); output.WriteMessage(Certificate); } - if (statsCase_ == StatsOneofCase.Track) { + if (statsCase_ == StatsOneofCase.Stream) { output.WriteRawTag(138, 1); + output.WriteMessage(Stream); + } + if (statsCase_ == StatsOneofCase.Track) { + output.WriteRawTag(146, 1); output.WriteMessage(Track); } if (_unknownFields != null) { @@ -927,6 +960,9 @@ public int CalculateSize() { if (statsCase_ == StatsOneofCase.Certificate) { size += 2 + pb::CodedOutputStream.ComputeMessageSize(Certificate); } + if (statsCase_ == StatsOneofCase.Stream) { + size += 2 + pb::CodedOutputStream.ComputeMessageSize(Stream); + } if (statsCase_ == StatsOneofCase.Track) { size += 2 + pb::CodedOutputStream.ComputeMessageSize(Track); } @@ -1027,6 +1063,12 @@ public void MergeFrom(RtcStats other) { } Certificate.MergeFrom(other.Certificate); break; + case StatsOneofCase.Stream: + if (Stream == null) { + Stream = new global::LiveKit.Proto.RtcStats.Types.Stream(); + } + Stream.MergeFrom(other.Stream); + break; case StatsOneofCase.Track: if (Track == null) { Track = new global::LiveKit.Proto.RtcStats.Types.Track(); @@ -1181,6 +1223,15 @@ public void MergeFrom(pb::CodedInputStream input) { break; } case 138: { + global::LiveKit.Proto.RtcStats.Types.Stream subBuilder = new global::LiveKit.Proto.RtcStats.Types.Stream(); + if (statsCase_ == StatsOneofCase.Stream) { + subBuilder.MergeFrom(Stream); + } + input.ReadMessage(subBuilder); + Stream = subBuilder; + break; + } + case 146: { global::LiveKit.Proto.RtcStats.Types.Track subBuilder = new global::LiveKit.Proto.RtcStats.Types.Track(); if (statsCase_ == StatsOneofCase.Track) { subBuilder.MergeFrom(Track); @@ -1335,6 +1386,15 @@ public void MergeFrom(pb::CodedInputStream input) { break; } case 138: { + global::LiveKit.Proto.RtcStats.Types.Stream subBuilder = new global::LiveKit.Proto.RtcStats.Types.Stream(); + if (statsCase_ == StatsOneofCase.Stream) { + subBuilder.MergeFrom(Stream); + } + input.ReadMessage(subBuilder); + Stream = subBuilder; + break; + } + case 146: { global::LiveKit.Proto.RtcStats.Types.Track subBuilder = new global::LiveKit.Proto.RtcStats.Types.Track(); if (statsCase_ == StatsOneofCase.Track) { subBuilder.MergeFrom(Track); @@ -5355,6 +5415,259 @@ public void MergeFrom(pb::CodedInputStream input) { } + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class Stream : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new Stream()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.RtcStats.Descriptor.NestedTypes[14]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public Stream() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public Stream(Stream other) : this() { + rtc_ = other.rtc_ != null ? other.rtc_.Clone() : null; + stream_ = other.stream_ != null ? other.stream_.Clone() : null; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public Stream Clone() { + return new Stream(this); + } + + /// Field number for the "rtc" field. + public const int RtcFieldNumber = 1; + private global::LiveKit.Proto.RtcStatsData rtc_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.RtcStatsData Rtc { + get { return rtc_; } + set { + rtc_ = value; + } + } + + /// Field number for the "stream" field. + public const int Stream_FieldNumber = 2; + private global::LiveKit.Proto.StreamStats stream_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public global::LiveKit.Proto.StreamStats Stream_ { + get { return stream_; } + set { + stream_ = value; + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as Stream); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(Stream other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (!object.Equals(Rtc, other.Rtc)) return false; + if (!object.Equals(Stream_, other.Stream_)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (rtc_ != null) hash ^= Rtc.GetHashCode(); + if (stream_ != null) hash ^= Stream_.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (rtc_ != null) { + output.WriteRawTag(10); + output.WriteMessage(Rtc); + } + if (stream_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Stream_); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (rtc_ != null) { + output.WriteRawTag(10); + output.WriteMessage(Rtc); + } + if (stream_ != null) { + output.WriteRawTag(18); + output.WriteMessage(Stream_); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (rtc_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Rtc); + } + if (stream_ != null) { + size += 1 + pb::CodedOutputStream.ComputeMessageSize(Stream_); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(Stream other) { + if (other == null) { + return; + } + if (other.rtc_ != null) { + if (rtc_ == null) { + Rtc = new global::LiveKit.Proto.RtcStatsData(); + } + Rtc.MergeFrom(other.Rtc); + } + if (other.stream_ != null) { + if (stream_ == null) { + Stream_ = new global::LiveKit.Proto.StreamStats(); + } + Stream_.MergeFrom(other.Stream_); + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + if (rtc_ == null) { + Rtc = new global::LiveKit.Proto.RtcStatsData(); + } + input.ReadMessage(Rtc); + break; + } + case 18: { + if (stream_ == null) { + Stream_ = new global::LiveKit.Proto.StreamStats(); + } + input.ReadMessage(Stream_); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + if (rtc_ == null) { + Rtc = new global::LiveKit.Proto.RtcStatsData(); + } + input.ReadMessage(Rtc); + break; + } + case 18: { + if (stream_ == null) { + Stream_ = new global::LiveKit.Proto.StreamStats(); + } + input.ReadMessage(Stream_); + break; + } + } + } + } + #endif + + } + /// /// Deprecated /// @@ -5373,7 +5686,7 @@ public sealed partial class Track : pb::IMessage [global::System.Diagnostics.DebuggerNonUserCodeAttribute] [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] public static pbr::MessageDescriptor Descriptor { - get { return global::LiveKit.Proto.RtcStats.Descriptor.NestedTypes[14]; } + get { return global::LiveKit.Proto.RtcStats.Descriptor.NestedTypes[15]; } } [global::System.Diagnostics.DebuggerNonUserCodeAttribute] @@ -18791,6 +19104,272 @@ public void MergeFrom(pb::CodedInputStream input) { } + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class StreamStats : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new StreamStats()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.StatsReflection.Descriptor.MessageTypes[20]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public StreamStats() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public StreamStats(StreamStats other) : this() { + id_ = other.id_; + streamIdentifier_ = other.streamIdentifier_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public StreamStats Clone() { + return new StreamStats(this); + } + + /// Field number for the "id" field. + public const int IdFieldNumber = 1; + private readonly static string IdDefaultValue = ""; + + private string id_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string Id { + get { return id_ ?? IdDefaultValue; } + set { + id_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + /// Gets whether the "id" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasId { + get { return id_ != null; } + } + /// Clears the value of the "id" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearId() { + id_ = null; + } + + /// Field number for the "stream_identifier" field. + public const int StreamIdentifierFieldNumber = 2; + private readonly static string StreamIdentifierDefaultValue = ""; + + private string streamIdentifier_; + /// + /// required int64 timestamp = 3; + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string StreamIdentifier { + get { return streamIdentifier_ ?? StreamIdentifierDefaultValue; } + set { + streamIdentifier_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + /// Gets whether the "stream_identifier" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasStreamIdentifier { + get { return streamIdentifier_ != null; } + } + /// Clears the value of the "stream_identifier" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearStreamIdentifier() { + streamIdentifier_ = null; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as StreamStats); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(StreamStats other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Id != other.Id) return false; + if (StreamIdentifier != other.StreamIdentifier) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (HasId) hash ^= Id.GetHashCode(); + if (HasStreamIdentifier) hash ^= StreamIdentifier.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (HasId) { + output.WriteRawTag(10); + output.WriteString(Id); + } + if (HasStreamIdentifier) { + output.WriteRawTag(18); + output.WriteString(StreamIdentifier); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (HasId) { + output.WriteRawTag(10); + output.WriteString(Id); + } + if (HasStreamIdentifier) { + output.WriteRawTag(18); + output.WriteString(StreamIdentifier); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (HasId) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Id); + } + if (HasStreamIdentifier) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(StreamIdentifier); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(StreamStats other) { + if (other == null) { + return; + } + if (other.HasId) { + Id = other.Id; + } + if (other.HasStreamIdentifier) { + StreamIdentifier = other.StreamIdentifier; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + Id = input.ReadString(); + break; + } + case 18: { + StreamIdentifier = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + Id = input.ReadString(); + break; + } + case 18: { + StreamIdentifier = input.ReadString(); + break; + } + } + } + } + #endif + + } + #endregion } diff --git a/Runtime/Scripts/Proto/Track.cs b/Runtime/Scripts/Proto/Track.cs index b81b56ab..feeb85ba 100644 --- a/Runtime/Scripts/Proto/Track.cs +++ b/Runtime/Scripts/Proto/Track.cs @@ -55,13 +55,20 @@ static TrackReflection() { "KAgiJwoWTG9jYWxUcmFja011dGVSZXNwb25zZRINCgVtdXRlZBgBIAIoCCJB", "ChhFbmFibGVSZW1vdGVUcmFja1JlcXVlc3QSFAoMdHJhY2tfaGFuZGxlGAEg", "AigEEg8KB2VuYWJsZWQYAiACKAgiLAoZRW5hYmxlUmVtb3RlVHJhY2tSZXNw", - "b25zZRIPCgdlbmFibGVkGAEgAigIKj0KCVRyYWNrS2luZBIQCgxLSU5EX1VO", - "S05PV04QABIOCgpLSU5EX0FVRElPEAESDgoKS0lORF9WSURFTxACKoEBCgtU", - "cmFja1NvdXJjZRISCg5TT1VSQ0VfVU5LTk9XThAAEhEKDVNPVVJDRV9DQU1F", - "UkEQARIVChFTT1VSQ0VfTUlDUk9QSE9ORRACEhYKElNPVVJDRV9TQ1JFRU5T", - "SEFSRRADEhwKGFNPVVJDRV9TQ1JFRU5TSEFSRV9BVURJTxAEKkQKC1N0cmVh", - "bVN0YXRlEhEKDVNUQVRFX1VOS05PV04QABIQCgxTVEFURV9BQ1RJVkUQARIQ", - "CgxTVEFURV9QQVVTRUQQAkIQqgINTGl2ZUtpdC5Qcm90bw==")); + "b25zZRIPCgdlbmFibGVkGAEgAigIIqwBCiZTZXRUcmFja1N1YnNjcmlwdGlv", + "blBlcm1pc3Npb25zUmVxdWVzdBIgChhsb2NhbF9wYXJ0aWNpcGFudF9oYW5k", + "bGUYASACKAQSIAoYYWxsX3BhcnRpY2lwYW50c19hbGxvd2VkGAIgAigIEj4K", + "C3Blcm1pc3Npb25zGAMgAygLMikubGl2ZWtpdC5wcm90by5QYXJ0aWNpcGFu", + "dFRyYWNrUGVybWlzc2lvbiJpChpQYXJ0aWNpcGFudFRyYWNrUGVybWlzc2lv", + "bhIcChRwYXJ0aWNpcGFudF9pZGVudGl0eRgBIAIoCRIRCglhbGxvd19hbGwY", + "AiABKAgSGgoSYWxsb3dlZF90cmFja19zaWRzGAMgAygJIikKJ1NldFRyYWNr", + "U3Vic2NyaXB0aW9uUGVybWlzc2lvbnNSZXNwb25zZSo9CglUcmFja0tpbmQS", + "EAoMS0lORF9VTktOT1dOEAASDgoKS0lORF9BVURJTxABEg4KCktJTkRfVklE", + "RU8QAiqBAQoLVHJhY2tTb3VyY2USEgoOU09VUkNFX1VOS05PV04QABIRCg1T", + "T1VSQ0VfQ0FNRVJBEAESFQoRU09VUkNFX01JQ1JPUEhPTkUQAhIWChJTT1VS", + "Q0VfU0NSRUVOU0hBUkUQAxIcChhTT1VSQ0VfU0NSRUVOU0hBUkVfQVVESU8Q", + "BCpECgtTdHJlYW1TdGF0ZRIRCg1TVEFURV9VTktOT1dOEAASEAoMU1RBVEVf", + "QUNUSVZFEAESEAoMU1RBVEVfUEFVU0VEEAJCEKoCDUxpdmVLaXQuUHJvdG8=")); descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData, new pbr::FileDescriptor[] { global::LiveKit.Proto.E2EeReflection.Descriptor, global::LiveKit.Proto.HandleReflection.Descriptor, global::LiveKit.Proto.StatsReflection.Descriptor, }, new pbr::GeneratedClrTypeInfo(new[] {typeof(global::LiveKit.Proto.TrackKind), typeof(global::LiveKit.Proto.TrackSource), typeof(global::LiveKit.Proto.StreamState), }, null, new pbr::GeneratedClrTypeInfo[] { @@ -80,7 +87,10 @@ static TrackReflection() { new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.LocalTrackMuteRequest), global::LiveKit.Proto.LocalTrackMuteRequest.Parser, new[]{ "TrackHandle", "Mute" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.LocalTrackMuteResponse), global::LiveKit.Proto.LocalTrackMuteResponse.Parser, new[]{ "Muted" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.EnableRemoteTrackRequest), global::LiveKit.Proto.EnableRemoteTrackRequest.Parser, new[]{ "TrackHandle", "Enabled" }, null, null, null, null), - new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.EnableRemoteTrackResponse), global::LiveKit.Proto.EnableRemoteTrackResponse.Parser, new[]{ "Enabled" }, null, null, null, null) + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.EnableRemoteTrackResponse), global::LiveKit.Proto.EnableRemoteTrackResponse.Parser, new[]{ "Enabled" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.SetTrackSubscriptionPermissionsRequest), global::LiveKit.Proto.SetTrackSubscriptionPermissionsRequest.Parser, new[]{ "LocalParticipantHandle", "AllParticipantsAllowed", "Permissions" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.ParticipantTrackPermission), global::LiveKit.Proto.ParticipantTrackPermission.Parser, new[]{ "ParticipantIdentity", "AllowAll", "AllowedTrackSids" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.SetTrackSubscriptionPermissionsResponse), global::LiveKit.Proto.SetTrackSubscriptionPermissionsResponse.Parser, null, null, null, null, null) })); } #endregion @@ -4626,6 +4636,761 @@ public void MergeFrom(pb::CodedInputStream input) { } + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class SetTrackSubscriptionPermissionsRequest : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new SetTrackSubscriptionPermissionsRequest()); + private pb::UnknownFieldSet _unknownFields; + private int _hasBits0; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.TrackReflection.Descriptor.MessageTypes[16]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SetTrackSubscriptionPermissionsRequest() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SetTrackSubscriptionPermissionsRequest(SetTrackSubscriptionPermissionsRequest other) : this() { + _hasBits0 = other._hasBits0; + localParticipantHandle_ = other.localParticipantHandle_; + allParticipantsAllowed_ = other.allParticipantsAllowed_; + permissions_ = other.permissions_.Clone(); + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SetTrackSubscriptionPermissionsRequest Clone() { + return new SetTrackSubscriptionPermissionsRequest(this); + } + + /// Field number for the "local_participant_handle" field. + public const int LocalParticipantHandleFieldNumber = 1; + private readonly static ulong LocalParticipantHandleDefaultValue = 0UL; + + private ulong localParticipantHandle_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ulong LocalParticipantHandle { + get { if ((_hasBits0 & 1) != 0) { return localParticipantHandle_; } else { return LocalParticipantHandleDefaultValue; } } + set { + _hasBits0 |= 1; + localParticipantHandle_ = value; + } + } + /// Gets whether the "local_participant_handle" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasLocalParticipantHandle { + get { return (_hasBits0 & 1) != 0; } + } + /// Clears the value of the "local_participant_handle" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearLocalParticipantHandle() { + _hasBits0 &= ~1; + } + + /// Field number for the "all_participants_allowed" field. + public const int AllParticipantsAllowedFieldNumber = 2; + private readonly static bool AllParticipantsAllowedDefaultValue = false; + + private bool allParticipantsAllowed_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool AllParticipantsAllowed { + get { if ((_hasBits0 & 2) != 0) { return allParticipantsAllowed_; } else { return AllParticipantsAllowedDefaultValue; } } + set { + _hasBits0 |= 2; + allParticipantsAllowed_ = value; + } + } + /// Gets whether the "all_participants_allowed" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasAllParticipantsAllowed { + get { return (_hasBits0 & 2) != 0; } + } + /// Clears the value of the "all_participants_allowed" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearAllParticipantsAllowed() { + _hasBits0 &= ~2; + } + + /// Field number for the "permissions" field. + public const int PermissionsFieldNumber = 3; + private static readonly pb::FieldCodec _repeated_permissions_codec + = pb::FieldCodec.ForMessage(26, global::LiveKit.Proto.ParticipantTrackPermission.Parser); + private readonly pbc::RepeatedField permissions_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField Permissions { + get { return permissions_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as SetTrackSubscriptionPermissionsRequest); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(SetTrackSubscriptionPermissionsRequest other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (LocalParticipantHandle != other.LocalParticipantHandle) return false; + if (AllParticipantsAllowed != other.AllParticipantsAllowed) return false; + if(!permissions_.Equals(other.permissions_)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (HasLocalParticipantHandle) hash ^= LocalParticipantHandle.GetHashCode(); + if (HasAllParticipantsAllowed) hash ^= AllParticipantsAllowed.GetHashCode(); + hash ^= permissions_.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (HasLocalParticipantHandle) { + output.WriteRawTag(8); + output.WriteUInt64(LocalParticipantHandle); + } + if (HasAllParticipantsAllowed) { + output.WriteRawTag(16); + output.WriteBool(AllParticipantsAllowed); + } + permissions_.WriteTo(output, _repeated_permissions_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (HasLocalParticipantHandle) { + output.WriteRawTag(8); + output.WriteUInt64(LocalParticipantHandle); + } + if (HasAllParticipantsAllowed) { + output.WriteRawTag(16); + output.WriteBool(AllParticipantsAllowed); + } + permissions_.WriteTo(ref output, _repeated_permissions_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (HasLocalParticipantHandle) { + size += 1 + pb::CodedOutputStream.ComputeUInt64Size(LocalParticipantHandle); + } + if (HasAllParticipantsAllowed) { + size += 1 + 1; + } + size += permissions_.CalculateSize(_repeated_permissions_codec); + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(SetTrackSubscriptionPermissionsRequest other) { + if (other == null) { + return; + } + if (other.HasLocalParticipantHandle) { + LocalParticipantHandle = other.LocalParticipantHandle; + } + if (other.HasAllParticipantsAllowed) { + AllParticipantsAllowed = other.AllParticipantsAllowed; + } + permissions_.Add(other.permissions_); + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + LocalParticipantHandle = input.ReadUInt64(); + break; + } + case 16: { + AllParticipantsAllowed = input.ReadBool(); + break; + } + case 26: { + permissions_.AddEntriesFrom(input, _repeated_permissions_codec); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + LocalParticipantHandle = input.ReadUInt64(); + break; + } + case 16: { + AllParticipantsAllowed = input.ReadBool(); + break; + } + case 26: { + permissions_.AddEntriesFrom(ref input, _repeated_permissions_codec); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class ParticipantTrackPermission : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ParticipantTrackPermission()); + private pb::UnknownFieldSet _unknownFields; + private int _hasBits0; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.TrackReflection.Descriptor.MessageTypes[17]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ParticipantTrackPermission() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ParticipantTrackPermission(ParticipantTrackPermission other) : this() { + _hasBits0 = other._hasBits0; + participantIdentity_ = other.participantIdentity_; + allowAll_ = other.allowAll_; + allowedTrackSids_ = other.allowedTrackSids_.Clone(); + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ParticipantTrackPermission Clone() { + return new ParticipantTrackPermission(this); + } + + /// Field number for the "participant_identity" field. + public const int ParticipantIdentityFieldNumber = 1; + private readonly static string ParticipantIdentityDefaultValue = ""; + + private string participantIdentity_; + /// + /// The participant identity this permission applies to. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public string ParticipantIdentity { + get { return participantIdentity_ ?? ParticipantIdentityDefaultValue; } + set { + participantIdentity_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + /// Gets whether the "participant_identity" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasParticipantIdentity { + get { return participantIdentity_ != null; } + } + /// Clears the value of the "participant_identity" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearParticipantIdentity() { + participantIdentity_ = null; + } + + /// Field number for the "allow_all" field. + public const int AllowAllFieldNumber = 2; + private readonly static bool AllowAllDefaultValue = false; + + private bool allowAll_; + /// + /// Grant permission to all all tracks. Takes precedence over allowedTrackSids. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool AllowAll { + get { if ((_hasBits0 & 1) != 0) { return allowAll_; } else { return AllowAllDefaultValue; } } + set { + _hasBits0 |= 1; + allowAll_ = value; + } + } + /// Gets whether the "allow_all" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasAllowAll { + get { return (_hasBits0 & 1) != 0; } + } + /// Clears the value of the "allow_all" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearAllowAll() { + _hasBits0 &= ~1; + } + + /// Field number for the "allowed_track_sids" field. + public const int AllowedTrackSidsFieldNumber = 3; + private static readonly pb::FieldCodec _repeated_allowedTrackSids_codec + = pb::FieldCodec.ForString(26); + private readonly pbc::RepeatedField allowedTrackSids_ = new pbc::RepeatedField(); + /// + /// List of track sids to grant permission to. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public pbc::RepeatedField AllowedTrackSids { + get { return allowedTrackSids_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as ParticipantTrackPermission); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(ParticipantTrackPermission other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (ParticipantIdentity != other.ParticipantIdentity) return false; + if (AllowAll != other.AllowAll) return false; + if(!allowedTrackSids_.Equals(other.allowedTrackSids_)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (HasParticipantIdentity) hash ^= ParticipantIdentity.GetHashCode(); + if (HasAllowAll) hash ^= AllowAll.GetHashCode(); + hash ^= allowedTrackSids_.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (HasParticipantIdentity) { + output.WriteRawTag(10); + output.WriteString(ParticipantIdentity); + } + if (HasAllowAll) { + output.WriteRawTag(16); + output.WriteBool(AllowAll); + } + allowedTrackSids_.WriteTo(output, _repeated_allowedTrackSids_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (HasParticipantIdentity) { + output.WriteRawTag(10); + output.WriteString(ParticipantIdentity); + } + if (HasAllowAll) { + output.WriteRawTag(16); + output.WriteBool(AllowAll); + } + allowedTrackSids_.WriteTo(ref output, _repeated_allowedTrackSids_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (HasParticipantIdentity) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(ParticipantIdentity); + } + if (HasAllowAll) { + size += 1 + 1; + } + size += allowedTrackSids_.CalculateSize(_repeated_allowedTrackSids_codec); + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(ParticipantTrackPermission other) { + if (other == null) { + return; + } + if (other.HasParticipantIdentity) { + ParticipantIdentity = other.ParticipantIdentity; + } + if (other.HasAllowAll) { + AllowAll = other.AllowAll; + } + allowedTrackSids_.Add(other.allowedTrackSids_); + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + ParticipantIdentity = input.ReadString(); + break; + } + case 16: { + AllowAll = input.ReadBool(); + break; + } + case 26: { + allowedTrackSids_.AddEntriesFrom(input, _repeated_allowedTrackSids_codec); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + ParticipantIdentity = input.ReadString(); + break; + } + case 16: { + AllowAll = input.ReadBool(); + break; + } + case 26: { + allowedTrackSids_.AddEntriesFrom(ref input, _repeated_allowedTrackSids_codec); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class SetTrackSubscriptionPermissionsResponse : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new SetTrackSubscriptionPermissionsResponse()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.TrackReflection.Descriptor.MessageTypes[18]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SetTrackSubscriptionPermissionsResponse() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SetTrackSubscriptionPermissionsResponse(SetTrackSubscriptionPermissionsResponse other) : this() { + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public SetTrackSubscriptionPermissionsResponse Clone() { + return new SetTrackSubscriptionPermissionsResponse(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as SetTrackSubscriptionPermissionsResponse); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(SetTrackSubscriptionPermissionsResponse other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(SetTrackSubscriptionPermissionsResponse other) { + if (other == null) { + return; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + } + } + } + #endif + + } + #endregion } diff --git a/Runtime/Scripts/Proto/TrackPublication.cs b/Runtime/Scripts/Proto/TrackPublication.cs new file mode 100644 index 00000000..a9021053 --- /dev/null +++ b/Runtime/Scripts/Proto/TrackPublication.cs @@ -0,0 +1,966 @@ +// +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: track_publication.proto +// +#pragma warning disable 1591, 0612, 3021, 8981 +#region Designer generated code + +using pb = global::Google.Protobuf; +using pbc = global::Google.Protobuf.Collections; +using pbr = global::Google.Protobuf.Reflection; +using scg = global::System.Collections.Generic; +namespace LiveKit.Proto { + + /// Holder for reflection information generated from track_publication.proto + public static partial class TrackPublicationReflection { + + #region Descriptor + /// File descriptor for track_publication.proto + public static pbr::FileDescriptor Descriptor { + get { return descriptor; } + } + private static pbr::FileDescriptor descriptor; + + static TrackPublicationReflection() { + byte[] descriptorData = global::System.Convert.FromBase64String( + string.Concat( + "Chd0cmFja19wdWJsaWNhdGlvbi5wcm90bxINbGl2ZWtpdC5wcm90byJYCiNF", + "bmFibGVSZW1vdGVUcmFja1B1YmxpY2F0aW9uUmVxdWVzdBIgChh0cmFja19w", + "dWJsaWNhdGlvbl9oYW5kbGUYASACKAQSDwoHZW5hYmxlZBgCIAIoCCImCiRF", + "bmFibGVSZW1vdGVUcmFja1B1YmxpY2F0aW9uUmVzcG9uc2UibwosVXBkYXRl", + "UmVtb3RlVHJhY2tQdWJsaWNhdGlvbkRpbWVuc2lvblJlcXVlc3QSIAoYdHJh", + "Y2tfcHVibGljYXRpb25faGFuZGxlGAEgAigEEg0KBXdpZHRoGAIgAigNEg4K", + "BmhlaWdodBgDIAIoDSIvCi1VcGRhdGVSZW1vdGVUcmFja1B1YmxpY2F0aW9u", + "RGltZW5zaW9uUmVzcG9uc2VCEKoCDUxpdmVLaXQuUHJvdG8=")); + descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData, + new pbr::FileDescriptor[] { }, + new pbr::GeneratedClrTypeInfo(null, null, new pbr::GeneratedClrTypeInfo[] { + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.EnableRemoteTrackPublicationRequest), global::LiveKit.Proto.EnableRemoteTrackPublicationRequest.Parser, new[]{ "TrackPublicationHandle", "Enabled" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.EnableRemoteTrackPublicationResponse), global::LiveKit.Proto.EnableRemoteTrackPublicationResponse.Parser, null, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.UpdateRemoteTrackPublicationDimensionRequest), global::LiveKit.Proto.UpdateRemoteTrackPublicationDimensionRequest.Parser, new[]{ "TrackPublicationHandle", "Width", "Height" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::LiveKit.Proto.UpdateRemoteTrackPublicationDimensionResponse), global::LiveKit.Proto.UpdateRemoteTrackPublicationDimensionResponse.Parser, null, null, null, null, null) + })); + } + #endregion + + } + #region Messages + /// + /// Enable/Disable a remote track publication + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class EnableRemoteTrackPublicationRequest : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new EnableRemoteTrackPublicationRequest()); + private pb::UnknownFieldSet _unknownFields; + private int _hasBits0; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.TrackPublicationReflection.Descriptor.MessageTypes[0]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public EnableRemoteTrackPublicationRequest() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public EnableRemoteTrackPublicationRequest(EnableRemoteTrackPublicationRequest other) : this() { + _hasBits0 = other._hasBits0; + trackPublicationHandle_ = other.trackPublicationHandle_; + enabled_ = other.enabled_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public EnableRemoteTrackPublicationRequest Clone() { + return new EnableRemoteTrackPublicationRequest(this); + } + + /// Field number for the "track_publication_handle" field. + public const int TrackPublicationHandleFieldNumber = 1; + private readonly static ulong TrackPublicationHandleDefaultValue = 0UL; + + private ulong trackPublicationHandle_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ulong TrackPublicationHandle { + get { if ((_hasBits0 & 1) != 0) { return trackPublicationHandle_; } else { return TrackPublicationHandleDefaultValue; } } + set { + _hasBits0 |= 1; + trackPublicationHandle_ = value; + } + } + /// Gets whether the "track_publication_handle" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasTrackPublicationHandle { + get { return (_hasBits0 & 1) != 0; } + } + /// Clears the value of the "track_publication_handle" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearTrackPublicationHandle() { + _hasBits0 &= ~1; + } + + /// Field number for the "enabled" field. + public const int EnabledFieldNumber = 2; + private readonly static bool EnabledDefaultValue = false; + + private bool enabled_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Enabled { + get { if ((_hasBits0 & 2) != 0) { return enabled_; } else { return EnabledDefaultValue; } } + set { + _hasBits0 |= 2; + enabled_ = value; + } + } + /// Gets whether the "enabled" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasEnabled { + get { return (_hasBits0 & 2) != 0; } + } + /// Clears the value of the "enabled" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearEnabled() { + _hasBits0 &= ~2; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as EnableRemoteTrackPublicationRequest); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(EnableRemoteTrackPublicationRequest other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (TrackPublicationHandle != other.TrackPublicationHandle) return false; + if (Enabled != other.Enabled) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (HasTrackPublicationHandle) hash ^= TrackPublicationHandle.GetHashCode(); + if (HasEnabled) hash ^= Enabled.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (HasTrackPublicationHandle) { + output.WriteRawTag(8); + output.WriteUInt64(TrackPublicationHandle); + } + if (HasEnabled) { + output.WriteRawTag(16); + output.WriteBool(Enabled); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (HasTrackPublicationHandle) { + output.WriteRawTag(8); + output.WriteUInt64(TrackPublicationHandle); + } + if (HasEnabled) { + output.WriteRawTag(16); + output.WriteBool(Enabled); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (HasTrackPublicationHandle) { + size += 1 + pb::CodedOutputStream.ComputeUInt64Size(TrackPublicationHandle); + } + if (HasEnabled) { + size += 1 + 1; + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(EnableRemoteTrackPublicationRequest other) { + if (other == null) { + return; + } + if (other.HasTrackPublicationHandle) { + TrackPublicationHandle = other.TrackPublicationHandle; + } + if (other.HasEnabled) { + Enabled = other.Enabled; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + TrackPublicationHandle = input.ReadUInt64(); + break; + } + case 16: { + Enabled = input.ReadBool(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + TrackPublicationHandle = input.ReadUInt64(); + break; + } + case 16: { + Enabled = input.ReadBool(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class EnableRemoteTrackPublicationResponse : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new EnableRemoteTrackPublicationResponse()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.TrackPublicationReflection.Descriptor.MessageTypes[1]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public EnableRemoteTrackPublicationResponse() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public EnableRemoteTrackPublicationResponse(EnableRemoteTrackPublicationResponse other) : this() { + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public EnableRemoteTrackPublicationResponse Clone() { + return new EnableRemoteTrackPublicationResponse(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as EnableRemoteTrackPublicationResponse); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(EnableRemoteTrackPublicationResponse other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(EnableRemoteTrackPublicationResponse other) { + if (other == null) { + return; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + } + } + } + #endif + + } + + /// + /// update a remote track publication dimension + /// + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class UpdateRemoteTrackPublicationDimensionRequest : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new UpdateRemoteTrackPublicationDimensionRequest()); + private pb::UnknownFieldSet _unknownFields; + private int _hasBits0; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.TrackPublicationReflection.Descriptor.MessageTypes[2]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public UpdateRemoteTrackPublicationDimensionRequest() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public UpdateRemoteTrackPublicationDimensionRequest(UpdateRemoteTrackPublicationDimensionRequest other) : this() { + _hasBits0 = other._hasBits0; + trackPublicationHandle_ = other.trackPublicationHandle_; + width_ = other.width_; + height_ = other.height_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public UpdateRemoteTrackPublicationDimensionRequest Clone() { + return new UpdateRemoteTrackPublicationDimensionRequest(this); + } + + /// Field number for the "track_publication_handle" field. + public const int TrackPublicationHandleFieldNumber = 1; + private readonly static ulong TrackPublicationHandleDefaultValue = 0UL; + + private ulong trackPublicationHandle_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public ulong TrackPublicationHandle { + get { if ((_hasBits0 & 1) != 0) { return trackPublicationHandle_; } else { return TrackPublicationHandleDefaultValue; } } + set { + _hasBits0 |= 1; + trackPublicationHandle_ = value; + } + } + /// Gets whether the "track_publication_handle" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasTrackPublicationHandle { + get { return (_hasBits0 & 1) != 0; } + } + /// Clears the value of the "track_publication_handle" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearTrackPublicationHandle() { + _hasBits0 &= ~1; + } + + /// Field number for the "width" field. + public const int WidthFieldNumber = 2; + private readonly static uint WidthDefaultValue = 0; + + private uint width_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public uint Width { + get { if ((_hasBits0 & 2) != 0) { return width_; } else { return WidthDefaultValue; } } + set { + _hasBits0 |= 2; + width_ = value; + } + } + /// Gets whether the "width" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasWidth { + get { return (_hasBits0 & 2) != 0; } + } + /// Clears the value of the "width" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearWidth() { + _hasBits0 &= ~2; + } + + /// Field number for the "height" field. + public const int HeightFieldNumber = 3; + private readonly static uint HeightDefaultValue = 0; + + private uint height_; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public uint Height { + get { if ((_hasBits0 & 4) != 0) { return height_; } else { return HeightDefaultValue; } } + set { + _hasBits0 |= 4; + height_ = value; + } + } + /// Gets whether the "height" field is set + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool HasHeight { + get { return (_hasBits0 & 4) != 0; } + } + /// Clears the value of the "height" field + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void ClearHeight() { + _hasBits0 &= ~4; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as UpdateRemoteTrackPublicationDimensionRequest); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(UpdateRemoteTrackPublicationDimensionRequest other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (TrackPublicationHandle != other.TrackPublicationHandle) return false; + if (Width != other.Width) return false; + if (Height != other.Height) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (HasTrackPublicationHandle) hash ^= TrackPublicationHandle.GetHashCode(); + if (HasWidth) hash ^= Width.GetHashCode(); + if (HasHeight) hash ^= Height.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (HasTrackPublicationHandle) { + output.WriteRawTag(8); + output.WriteUInt64(TrackPublicationHandle); + } + if (HasWidth) { + output.WriteRawTag(16); + output.WriteUInt32(Width); + } + if (HasHeight) { + output.WriteRawTag(24); + output.WriteUInt32(Height); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (HasTrackPublicationHandle) { + output.WriteRawTag(8); + output.WriteUInt64(TrackPublicationHandle); + } + if (HasWidth) { + output.WriteRawTag(16); + output.WriteUInt32(Width); + } + if (HasHeight) { + output.WriteRawTag(24); + output.WriteUInt32(Height); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (HasTrackPublicationHandle) { + size += 1 + pb::CodedOutputStream.ComputeUInt64Size(TrackPublicationHandle); + } + if (HasWidth) { + size += 1 + pb::CodedOutputStream.ComputeUInt32Size(Width); + } + if (HasHeight) { + size += 1 + pb::CodedOutputStream.ComputeUInt32Size(Height); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(UpdateRemoteTrackPublicationDimensionRequest other) { + if (other == null) { + return; + } + if (other.HasTrackPublicationHandle) { + TrackPublicationHandle = other.TrackPublicationHandle; + } + if (other.HasWidth) { + Width = other.Width; + } + if (other.HasHeight) { + Height = other.Height; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + TrackPublicationHandle = input.ReadUInt64(); + break; + } + case 16: { + Width = input.ReadUInt32(); + break; + } + case 24: { + Height = input.ReadUInt32(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + TrackPublicationHandle = input.ReadUInt64(); + break; + } + case 16: { + Width = input.ReadUInt32(); + break; + } + case 24: { + Height = input.ReadUInt32(); + break; + } + } + } + } + #endif + + } + + [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")] + public sealed partial class UpdateRemoteTrackPublicationDimensionResponse : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new UpdateRemoteTrackPublicationDimensionResponse()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public static pbr::MessageDescriptor Descriptor { + get { return global::LiveKit.Proto.TrackPublicationReflection.Descriptor.MessageTypes[3]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public UpdateRemoteTrackPublicationDimensionResponse() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public UpdateRemoteTrackPublicationDimensionResponse(UpdateRemoteTrackPublicationDimensionResponse other) : this() { + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public UpdateRemoteTrackPublicationDimensionResponse Clone() { + return new UpdateRemoteTrackPublicationDimensionResponse(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override bool Equals(object other) { + return Equals(other as UpdateRemoteTrackPublicationDimensionResponse); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public bool Equals(UpdateRemoteTrackPublicationDimensionResponse other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override int GetHashCode() { + int hash = 1; + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public int CalculateSize() { + int size = 0; + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(UpdateRemoteTrackPublicationDimensionResponse other) { + if (other == null) { + return; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + if ((tag & 7) == 4) { + // Abort on any end group tag. + return; + } + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + } + } + } + #endif + + } + + #endregion + +} + +#endregion Designer generated code diff --git a/Runtime/Scripts/Proto/TrackPublication.cs.meta b/Runtime/Scripts/Proto/TrackPublication.cs.meta new file mode 100644 index 00000000..877637bf --- /dev/null +++ b/Runtime/Scripts/Proto/TrackPublication.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 44d6f6023294140bba6d5b9e39c8d8ff +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Runtime/Scripts/Proto/VideoFrame.cs b/Runtime/Scripts/Proto/VideoFrame.cs index 631693e9..6913e5f3 100644 --- a/Runtime/Scripts/Proto/VideoFrame.cs +++ b/Runtime/Scripts/Proto/VideoFrame.cs @@ -56,7 +56,7 @@ static VideoFrameReflection() { "Eg4KBmhlaWdodBgCIAIoDRISCgpmcmFtZV9yYXRlGAMgAigBIoMCCg9WaWRl", "b0J1ZmZlckluZm8SLAoEdHlwZRgBIAIoDjIeLmxpdmVraXQucHJvdG8uVmlk", "ZW9CdWZmZXJUeXBlEg0KBXdpZHRoGAIgAigNEg4KBmhlaWdodBgDIAIoDRIQ", - "CghkYXRhX3B0chgEIAIoBBIOCgZzdHJpZGUYBiACKA0SQAoKY29tcG9uZW50", + "CghkYXRhX3B0chgEIAIoBBIOCgZzdHJpZGUYBiABKA0SQAoKY29tcG9uZW50", "cxgHIAMoCzIsLmxpdmVraXQucHJvdG8uVmlkZW9CdWZmZXJJbmZvLkNvbXBv", "bmVudEluZm8aPwoNQ29tcG9uZW50SW5mbxIQCghkYXRhX3B0chgBIAIoBBIO", "CgZzdHJpZGUYAiACKA0SDAoEc2l6ZRgDIAIoDSJvChBPd25lZFZpZGVvQnVm", @@ -133,6 +133,10 @@ public enum VideoRotation { [pbr::OriginalName("VIDEO_ROTATION_270")] _270 = 3, } + /// + /// Values of this enum must not be changed + /// It is used to serialize a rtc.VideoFrame on Python + /// public enum VideoBufferType { [pbr::OriginalName("RGBA")] Rgba = 0, [pbr::OriginalName("ABGR")] Abgr = 1, diff --git a/Runtime/Scripts/Room.cs b/Runtime/Scripts/Room.cs index 870d8fed..5c542473 100644 --- a/Runtime/Scripts/Room.cs +++ b/Runtime/Scripts/Room.cs @@ -4,6 +4,7 @@ using LiveKit.Proto; using System.Runtime.InteropServices; using LiveKit.Internal.FFIClients.Requests; +using UnityEngine; namespace LiveKit { @@ -48,7 +49,7 @@ public Proto.RtcConfig ToProto() { var proto = new Proto.RtcConfig(); - switch(ContinualGatheringPolicy) + switch (ContinualGatheringPolicy) { case ContinualGatheringPolicy.GATHER_ONCE: proto.ContinualGatheringPolicy = Proto.ContinualGatheringPolicy.GatherOnce; @@ -58,7 +59,7 @@ public Proto.RtcConfig ToProto() break; } - switch(IceTransportType) + switch (IceTransportType) { case IceTransportType.TRANSPORT_ALL: proto.IceTransportType = Proto.IceTransportType.TransportAll; @@ -71,7 +72,7 @@ public Proto.RtcConfig ToProto() break; } - foreach(var item in IceServers) + foreach (var item in IceServers) { proto.IceServers.Add(item.ToProto()); } @@ -109,6 +110,7 @@ public class Room { internal FfiHandle RoomHandle = null; private readonly Dictionary _participants = new(); + private StreamHandlerRegistry _streamHandlers = new(); public delegate void MetaDelegate(string metaData); public delegate void ParticipantDelegate(Participant participant); @@ -166,7 +168,7 @@ public ConnectInstruction Connect(string url, string token, RoomOptions options) Utils.Debug($"Connect response.... {response}"); return new ConnectInstruction(res.Connect.AsyncId, this, options); } - + public void Disconnect() { if (this.RoomHandle == null) @@ -177,6 +179,54 @@ public void Disconnect() Utils.Debug($"Disconnect response.... {resp}"); } + /// + /// Registers a handler for incoming text streams matching the given topic. + /// + /// Topic identifier that filters which streams will be handled. + /// Only streams with a matching topic will trigger the handler. + /// Handler that is invoked whenever a remote participant + /// opens a new stream with the matching topic. The handler receives a + /// for consuming the stream data and the identity of + /// the remote participant who initiated the stream. + /// Throws a if the topic is already registered. + public void RegisterTextStreamHandler(string topic, TextStreamHandler handler) + { + _streamHandlers.RegisterTextStreamHandler(topic, handler); + } + + /// + /// Registers a handler for incoming byte streams matching the given topic. + /// + /// Topic identifier that filters which streams will be handled. + /// Only streams with a matching topic will trigger the handler. + /// Handler that is invoked whenever a remote participant + /// opens a new stream with the matching topic. The handler receives a + /// for consuming the stream data and the identity of + /// the remote participant who initiated the stream. + /// Throws a if the topic is already registered. + public void RegisterByteStreamHandler(string topic, ByteStreamHandler handler) + { + _streamHandlers.RegisterByteStreamHandler(topic, handler); + } + + /// + /// Unregisters a handler for incoming text streams matching the given topic. + /// + /// Topic identifier for which the handler should be unregistered. + public void UnregisterTextStreamHandler(string topic) + { + _streamHandlers.UnregisterTextStreamHandler(topic); + } + + /// + /// Unregisters a handler for incoming byte streams matching the given topic. + /// + /// Topic identifier for which the handler should be unregistered. + public void UnregisterByteStreamHandler(string topic) + { + _streamHandlers.UnregisterByteStreamHandler(topic); + } + internal void UpdateFromInfo(RoomInfo info) { Sid = info.Sid; @@ -198,6 +248,7 @@ internal void OnRpcMethodInvocationReceived(RpcMethodInvocationEvent e) e.ResponseTimeoutMs / 1000f); } } + internal void OnEventReceived(RoomEvent e) { if (e.RoomHandle != (ulong)RoomHandle.DangerousGetHandle()) @@ -269,7 +320,7 @@ internal void OnEventReceived(RoomEvent e) var participant = RemoteParticipants[e.TrackSubscribed.ParticipantIdentity]; var publication = participant.Tracks[info.Sid]; - if(publication == null) + if (publication == null) { participant._tracks.Add(publication.Sid, publication); } @@ -361,7 +412,7 @@ internal void OnEventReceived(RoomEvent e) case RoomEvent.MessageOneofCase.DataPacketReceived: { var valueType = e.DataPacketReceived.ValueCase; - switch(valueType) + switch (valueType) { case DataPacketReceived.ValueOneofCase.None: //do nothing. @@ -389,6 +440,16 @@ internal void OnEventReceived(RoomEvent e) } } break; + case RoomEvent.MessageOneofCase.ByteStreamOpened: + var byteReader = new ByteStreamReader(e.ByteStreamOpened.Reader); + _streamHandlers.Dispatch(byteReader, e.ByteStreamOpened.ParticipantIdentity); + // TODO: Immediately dispose unhandled stream reader + break; + case RoomEvent.MessageOneofCase.TextStreamOpened: + var textReader = new TextStreamReader(e.TextStreamOpened.Reader); + _streamHandlers.Dispatch(textReader, e.TextStreamOpened.ParticipantIdentity); + // TODO: Immediately dispose unhandled stream reader + break; case RoomEvent.MessageOneofCase.ConnectionStateChanged: ConnectionState = e.ConnectionStateChanged.State; ConnectionStateChanged?.Invoke(e.ConnectionStateChanged.State); @@ -426,6 +487,7 @@ internal void OnConnect(ConnectCallback info) FfiClient.Instance.RoomEventReceived += OnEventReceived; FfiClient.Instance.DisconnectReceived += OnDisconnectReceived; FfiClient.Instance.RpcMethodInvocationReceived += OnRpcMethodInvocationReceived; + Connected?.Invoke(this); } @@ -496,7 +558,7 @@ void OnConnect(ConnectCallback e) bool success = string.IsNullOrEmpty(e.Error); if (success) { - if(_roomOptions.E2EE != null) + if (_roomOptions.E2EE != null) { _room.E2EEManager = new E2EEManager(_room.RoomHandle, _roomOptions.E2EE); } diff --git a/client-sdk-rust~ b/client-sdk-rust~ index fabd8ed8..da5c7131 160000 --- a/client-sdk-rust~ +++ b/client-sdk-rust~ @@ -1 +1 @@ -Subproject commit fabd8ed8e126eb35c9f0817470036137d83afd7e +Subproject commit da5c713107d573f28e82d69d91f509dbf6df79e7 diff --git a/version.ini b/version.ini index 0cb39ce6..a038a1ff 100644 --- a/version.ini +++ b/version.ini @@ -1,3 +1,3 @@ [ffi] -tag = rust-sdks/livekit-ffi@0.12.10 +tag = rust-sdks/livekit-ffi@0.12.20 url = https://github.com/livekit/rust-sdks/releases/download \ No newline at end of file