public void Subscribe(EventHandler <TResponse> value)
        {
            OnData += value;
            Task.Run(async() => {
                using NamedPipeClientStream stream = new NamedPipeClientStream(pipeName);
                using StreamReader reader          = new StreamReader(stream);
                using StreamWriter writer          = new StreamWriter(stream);

                await stream.ConnectAsync(5000, _externCancellationToken).ConfigureAwait(false);

                await writer.WriteLineAsync(request.ToJson()).ConfigureAwait(false);
                await writer.FlushAsync().ConfigureAwait(false);
                stream.WaitForPipeDrain();

                while (!_externCancellationToken.IsCancellationRequested && !unsubscribeToken.IsCancellationRequested)
                {
                    string responsJson             = await reader.ReadLineAsync().ConfigureAwait(false);
                    StreamlabsOBSResponse response = JsonConvert.DeserializeObject <StreamlabsOBSResponse>(responsJson);
                    response.JsonResponse          = responsJson;

                    if (response.Results.Value <string>("_type").Equals("SUBSCRIPTION"))
                    {
                        OnBegin?.Invoke(this, response);
                    }
                    else
                    if (response.Results.Value <string>("_type").Equals("EVENT"))
                    {
                        StreamlabsOBSEvent eventData = response.GetResultFirstOrDefault <StreamlabsOBSEvent>();

                        OnEvent?.Invoke(this, eventData);
                        if (typeof(TResponse).IsAssignableFrom(typeof(StreamlabsOBSEvent)))
                        {
                            OnData?.Invoke(this, eventData as TResponse);
                        }
                        else
                        {
                            OnData?.Invoke(this, eventData.GetDataFirstOrDefault <TResponse>());
                        }
                    }
                    else
                    {
                        OnUnsupported?.Invoke(this, responsJson);
                    }
                }
            },
                     _externCancellationToken);
        }
        public async Task <StreamlabsOBSResponse> SendRequestAsync(StreamlabsOBSRequest request,
                                                                   bool loadPromises = true)
        {
            using NamedPipeClientStream pipe = new NamedPipeClientStream(pipeName);
            using StreamReader reader        = new StreamReader(pipe);
            using StreamWriter writer        = new StreamWriter(pipe)
                  {
                      NewLine = "\n"
                  };

            await pipe.ConnectAsync(5000).ConfigureAwait(false);

            await writer.WriteLineAsync(request.ToJson()).ConfigureAwait(false);

            await writer.FlushAsync().ConfigureAwait(false);

            pipe.WaitForPipeDrain();

            string responsJson = await reader.ReadLineAsync().ConfigureAwait(false);

            StreamlabsOBSResponse response = JsonConvert.DeserializeObject <StreamlabsOBSResponse>(responsJson);

            response.JsonResponse = responsJson;

            if (!loadPromises)
            {
                return(response);
            }

            if (!response.IsEnumberabeResult() && response.Results.IsPromise())
            {
                response.Results = JsonConvert.DeserializeObject <StreamlabsOBSResponse>(await reader.ReadLineAsync().ConfigureAwait(false)).Results;
            }

            return(response);
        }