using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BoneLib;
using BoneLib.BoneMenu;
using BoneLib.Notifications;
using MelonLoader;
using MelonLoader.Preferences;
using MelonLoader.Utils;
using Microsoft.CodeAnalysis;
using OBSWebsocketDotNet;
using OBSWebsocketDotNet.Types;
using OBSWebsocketDotNet.Types.Events;
using UnityEngine;
using UnityEngine.Diagnostics;
using WeatherElectric.OBSControl;
using WeatherElectric.OBSControl.Handlers;
using WeatherElectric.OBSControl.Melon;
using WeatherElectric.OBSControl.Menu;
using WeatherElectric.OBSControl.OBS;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("Control OBS from within BONELAB.")]
[assembly: AssemblyDescription("Control OBS from within BONELAB.")]
[assembly: AssemblyCompany("Weather Electric")]
[assembly: AssemblyProduct("OBSControl")]
[assembly: AssemblyCopyright("Developed by SoulWithMae")]
[assembly: AssemblyTrademark("Weather Electric")]
[assembly: AssemblyFileVersion("1.1.2")]
[assembly: MelonInfo(typeof(Main), "OBSControl", "1.1.2", "SoulWithMae", "https://thunderstore.io/c/bonelab/p/SoulWithMae/OBSControl/")]
[assembly: MelonColor(255, 0, 0, 255)]
[assembly: MelonGame("Stress Level Zero", "BONELAB")]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyVersion("1.1.2.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace WeatherElectric.OBSControl
{
	internal static class ControlHandler
	{
		private static bool _isFirstTap;

		private static float _doubleTapTimer;

		public static void Update()
		{
			switch (Preferences.ReplayControlHand.Value)
			{
			case ControlHand.Left:
				HandleLeft();
				break;
			case ControlHand.Right:
				HandleRight();
				break;
			case ControlHand.Both:
				HandleBoth();
				break;
			default:
				throw new ArgumentOutOfRangeException();
			}
			if (_isFirstTap)
			{
				_doubleTapTimer += Time.deltaTime;
				if (_doubleTapTimer > Preferences.DoubleTapTime.Value)
				{
					_isFirstTap = false;
				}
			}
			static void HandleBoth()
			{
				if (Player.RightController._menuTap || Player.LeftController._menuTap)
				{
					if (!_isFirstTap)
					{
						_isFirstTap = true;
						_doubleTapTimer = 0f;
					}
					else if (_doubleTapTimer < Preferences.DoubleTapTime.Value)
					{
						ObsBridge.SaveReplayBuffer();
						NotificationHandler.SendNotif(NotificationHandler.ReplaySaved);
						_isFirstTap = false;
					}
				}
			}
			static void HandleLeft()
			{
				if (Player.LeftController._menuTap)
				{
					if (!_isFirstTap)
					{
						_isFirstTap = true;
						_doubleTapTimer = 0f;
					}
					else if (_doubleTapTimer < Preferences.DoubleTapTime.Value)
					{
						ObsBridge.SaveReplayBuffer();
						NotificationHandler.SendNotif(NotificationHandler.ReplaySaved);
						_isFirstTap = false;
					}
				}
			}
			static void HandleRight()
			{
				if (Player.RightController._menuTap)
				{
					if (!_isFirstTap)
					{
						_isFirstTap = true;
						_doubleTapTimer = 0f;
					}
					else if (_doubleTapTimer < Preferences.DoubleTapTime.Value)
					{
						ObsBridge.SaveReplayBuffer();
						NotificationHandler.SendNotif(NotificationHandler.ReplaySaved);
						_isFirstTap = false;
					}
				}
			}
		}
	}
	public class Main : MelonMod
	{
		internal const string Name = "OBSControl";

		internal const string Description = "Control OBS from within BONELAB.";

		internal const string Author = "SoulWithMae";

		internal const string Company = "Weather Electric";

		internal const string Version = "1.1.2";

		internal const string DownloadLink = "https://thunderstore.io/c/bonelab/p/SoulWithMae/OBSControl/";

		private static bool _rigExists;

		public override void OnInitializeMelon()
		{
			ModConsole.Setup(((MelonBase)this).LoggerInstance);
			Preferences.Setup();
			Hooking.OnUIRigCreated += OnUIRigCreated;
			Hooking.OnLevelUnloaded += OnLevelUnloaded;
			BoneMenu.SetupBaseMenu();
		}

		public override void OnApplicationQuit()
		{
			ObsBridge.Disconnect();
		}

		public override void OnUpdate()
		{
			if (_rigExists && ObsBridge.IsConnected())
			{
				ControlHandler.Update();
			}
		}

		private static void OnUIRigCreated()
		{
			_rigExists = true;
			if (!ObsBridge.IsConnected())
			{
				ObsBridge.Connect();
				ObsBridge.InitHooks();
			}
		}

		private static void OnLevelUnloaded()
		{
			_rigExists = false;
		}
	}
}
namespace WeatherElectric.OBSControl.OBS
{
	public static class ObsBridge
	{
		private static readonly OBSWebsocket Obs = new OBSWebsocket();

		public static Action<object, RecordStateChangedEventArgs> OnRecordStateChanged;

		public static Action<object, ReplayBufferSavedEventArgs> OnReplayBufferSaved;

		public static Action<object, ReplayBufferStateChangedEventArgs> OnReplayBufferStateChanged;

		public static Action<object, StreamStateChangedEventArgs> OnStreamStateChanged;

		public static Action<object, ProgramSceneChangedEventArgs> OnSceneChanged;

		public static Action<object, SceneCreatedEventArgs> OnSceneCreated;

		public static Action<object, VirtualcamStateChangedEventArgs> OnVirtualCamStateChanged;

		public static Action<object, SceneRemovedEventArgs> OnSceneRemoved;

		private static void RecordStateChanged(object sender, RecordStateChangedEventArgs e)
		{
			OnRecordStateChanged?.Invoke(sender, e);
		}

		private static void ReplaySaved(object sender, ReplayBufferSavedEventArgs e)
		{
			OnReplayBufferSaved?.Invoke(sender, e);
		}

		private static void ReplayStateChanged(object sender, ReplayBufferStateChangedEventArgs e)
		{
			OnReplayBufferStateChanged?.Invoke(sender, e);
		}

		private static void StreamStateChanged(object sender, StreamStateChangedEventArgs e)
		{
			OnStreamStateChanged?.Invoke(sender, e);
		}

		private static void SceneChanged(object sender, ProgramSceneChangedEventArgs e)
		{
			OnSceneChanged?.Invoke(sender, e);
		}

		private static void VirtualCamStateChanged(object sender, VirtualcamStateChangedEventArgs e)
		{
			OnVirtualCamStateChanged?.Invoke(sender, e);
		}

		private static void SceneCreated(object sender, SceneCreatedEventArgs e)
		{
			OnSceneCreated?.Invoke(sender, e);
		}

		private static void SceneRemoved(object sender, SceneRemovedEventArgs e)
		{
		}

		internal static void Connect()
		{
			//IL_003a: Expected O, but got Unknown
			ModConsole.Msg("Attempting to connect to OBS...", 1);
			try
			{
				Obs.ConnectAsync(Preferences.WebsocketURL.Value, Preferences.WebsocketPassword.Value);
			}
			catch (AuthFailureException)
			{
				ModConsole.Error("Failed to authenticate with OBS. Check your password.");
			}
			catch (ErrorResponseException val2)
			{
				ErrorResponseException val3 = val2;
				ModConsole.Error("Failed to connect to OBS. Error: " + ((Exception)(object)val3).Message);
			}
			catch (Exception ex)
			{
				ModConsole.Error("Failed to connect to OBS. Error: " + ex.Message);
			}
			ModConsole.Msg("If you still aren't connected, it's likely the wrong password.", 1);
		}

		internal static void Disconnect()
		{
			ModConsole.Msg("Disconnecting from OBS...", 1);
			Obs.Disconnect();
		}

		internal static void InitHooks()
		{
			Obs.RecordStateChanged += RecordStateChanged;
			Obs.ReplayBufferSaved += ReplaySaved;
			Obs.ReplayBufferStateChanged += ReplayStateChanged;
			Obs.StreamStateChanged += StreamStateChanged;
			Obs.CurrentProgramSceneChanged += SceneChanged;
			Obs.VirtualcamStateChanged += VirtualCamStateChanged;
			Obs.SceneCreated += SceneCreated;
			Obs.SceneRemoved += SceneRemoved;
			Obs.Connected += ObsConnected;
		}

		private static void ObsConnected(object sender, EventArgs e)
		{
			ModConsole.Msg("OBS connected!", 1);
			BoneMenu.SetupObsControls();
		}

		public static List<SceneBasicInfo> GetScenes()
		{
			return Obs.GetSceneList().Scenes;
		}

		public static void SetScene(string sceneName)
		{
			Obs.SetCurrentProgramScene(sceneName);
		}

		public static bool IsConnected()
		{
			return Obs.IsConnected;
		}

		public static bool IsRecording()
		{
			return Obs.GetRecordStatus().IsRecording;
		}

		public static bool IsRecordingPaused()
		{
			return Obs.GetRecordStatus().IsRecordingPaused;
		}

		public static bool IsStreaming()
		{
			return Obs.GetStreamStatus().IsActive;
		}

		public static bool IsReplayBufferActive()
		{
			return Obs.GetReplayBufferStatus();
		}

		public static bool IsVirtualCamActive()
		{
			return Obs.GetVirtualCamStatus().IsActive;
		}

		public static void StartRecording()
		{
			//IL_0020: Expected O, but got Unknown
			if (IsRecording())
			{
				return;
			}
			ModConsole.Msg("Starting recording...", 1);
			try
			{
				Obs.StartRecord();
			}
			catch (ErrorResponseException val)
			{
				ErrorResponseException val2 = val;
				ModConsole.Error("Failed to start recording. Error: " + ((Exception)(object)val2).Message);
			}
			catch (Exception ex)
			{
				ModConsole.Error("Failed to start recording. Error: " + ex.Message);
			}
		}

		public static void PauseRecording()
		{
			//IL_0020: Expected O, but got Unknown
			if (IsRecordingPaused())
			{
				return;
			}
			ModConsole.Msg("Pausing recording...", 1);
			try
			{
				Obs.PauseRecord();
			}
			catch (ErrorResponseException val)
			{
				ErrorResponseException val2 = val;
				ModConsole.Error("Failed to pause recording. Error: " + ((Exception)(object)val2).Message);
			}
			catch (Exception ex)
			{
				ModConsole.Error("Failed to pause recording. Error: " + ex.Message);
			}
		}

		public static void ResumeRecording()
		{
			//IL_0020: Expected O, but got Unknown
			if (!IsRecordingPaused())
			{
				return;
			}
			ModConsole.Msg("Resuming recording...", 1);
			try
			{
				Obs.ResumeRecord();
			}
			catch (ErrorResponseException val)
			{
				ErrorResponseException val2 = val;
				ModConsole.Error("Failed to resume recording. Error: " + ((Exception)(object)val2).Message);
			}
			catch (Exception ex)
			{
				ModConsole.Error("Failed to resume recording. Error: " + ex.Message);
			}
		}

		public static void StopRecording()
		{
			//IL_0021: Expected O, but got Unknown
			if (!IsRecording())
			{
				return;
			}
			ModConsole.Msg("Stopping recording...", 1);
			try
			{
				Obs.StopRecord();
			}
			catch (ErrorResponseException val)
			{
				ErrorResponseException val2 = val;
				ModConsole.Error("Failed to stop recording. Error: " + ((Exception)(object)val2).Message);
			}
			catch (Exception ex)
			{
				ModConsole.Error("Failed to stop recording. Error: " + ex.Message);
			}
		}

		public static void StartStreaming()
		{
			//IL_0020: Expected O, but got Unknown
			if (IsStreaming())
			{
				return;
			}
			ModConsole.Msg("Starting stream...", 1);
			try
			{
				Obs.StartStream();
			}
			catch (ErrorResponseException val)
			{
				ErrorResponseException val2 = val;
				ModConsole.Error("Failed to start streaming. Error: " + ((Exception)(object)val2).Message);
			}
			catch (Exception ex)
			{
				ModConsole.Error("Failed to start streaming. Error: " + ex.Message);
			}
		}

		public static void StopStreaming()
		{
			//IL_0020: Expected O, but got Unknown
			if (!IsStreaming())
			{
				return;
			}
			ModConsole.Msg("Stopping stream...", 1);
			try
			{
				Obs.StopStream();
			}
			catch (ErrorResponseException val)
			{
				ErrorResponseException val2 = val;
				ModConsole.Error("Failed to stop streaming. Error: " + ((Exception)(object)val2).Message);
			}
			catch (Exception ex)
			{
				ModConsole.Error("Failed to stop streaming. Error: " + ex.Message);
			}
		}

		public static void StartReplayBuffer()
		{
			//IL_0020: Expected O, but got Unknown
			if (IsReplayBufferActive())
			{
				return;
			}
			ModConsole.Msg("Starting replay buffer...", 1);
			try
			{
				Obs.StartReplayBuffer();
			}
			catch (ErrorResponseException val)
			{
				ErrorResponseException val2 = val;
				ModConsole.Error("Failed to start replay buffer. Error: " + ((Exception)(object)val2).Message);
			}
			catch (Exception ex)
			{
				ModConsole.Error("Failed to start replay buffer. Error: " + ex.Message);
			}
		}

		public static void StopReplayBuffer()
		{
			//IL_0020: Expected O, but got Unknown
			if (!IsReplayBufferActive())
			{
				return;
			}
			ModConsole.Msg("Stopping replay buffer...", 1);
			try
			{
				Obs.StopReplayBuffer();
			}
			catch (ErrorResponseException val)
			{
				ErrorResponseException val2 = val;
				ModConsole.Error("Failed to stop replay buffer. Error: " + ((Exception)(object)val2).Message);
			}
			catch (Exception ex)
			{
				ModConsole.Error("Failed to stop replay buffer. Error: " + ex.Message);
			}
		}

		public static void SaveReplayBuffer()
		{
			//IL_0020: Expected O, but got Unknown
			if (!IsReplayBufferActive())
			{
				return;
			}
			ModConsole.Msg("Saving replay buffer...", 1);
			try
			{
				Obs.SaveReplayBuffer();
			}
			catch (ErrorResponseException val)
			{
				ErrorResponseException val2 = val;
				ModConsole.Error("Failed to save replay buffer. Error: " + ((Exception)(object)val2).Message);
			}
			catch (Exception ex)
			{
				ModConsole.Error("Failed to save replay buffer. Error: " + ex.Message);
			}
		}
	}
}
namespace WeatherElectric.OBSControl.Melon
{
	internal static class ModConsole
	{
		private static Instance _logger;

		public static void Setup(Instance loggerInstance)
		{
			_logger = loggerInstance;
		}

		public static void Msg(object obj, int loggingMode = 0)
		{
			string text = ((loggingMode == 1) ? $"[DEBUG] {obj}" : obj.ToString());
			ConsoleColor consoleColor = ((loggingMode == 1) ? ConsoleColor.Yellow : ConsoleColor.Gray);
			if (Preferences.LoggingMode.Value >= loggingMode)
			{
				_logger.Msg(consoleColor, text);
			}
		}

		public static void Msg(string txt, int loggingMode = 0)
		{
			string text = ((loggingMode == 1) ? ("[DEBUG] " + txt) : txt);
			ConsoleColor consoleColor = ((loggingMode == 1) ? ConsoleColor.Yellow : ConsoleColor.Gray);
			if (Preferences.LoggingMode.Value >= loggingMode)
			{
				_logger.Msg(consoleColor, text);
			}
		}

		public static void Msg(ConsoleColor txtcolor, object obj, int loggingMode = 0)
		{
			string text = ((loggingMode == 1) ? $"[DEBUG] {obj}" : obj.ToString());
			if (Preferences.LoggingMode.Value >= loggingMode)
			{
				_logger.Msg(txtcolor, text);
			}
		}

		public static void Msg(ConsoleColor txtcolor, string txt, int loggingMode = 0)
		{
			string text = ((loggingMode == 1) ? ("[DEBUG] " + txt) : txt);
			if (Preferences.LoggingMode.Value >= loggingMode)
			{
				_logger.Msg(txtcolor, text);
			}
		}

		public static void Msg(string txt, int loggingMode = 0, params object[] args)
		{
			string text = ((loggingMode == 1) ? ("[DEBUG] " + txt) : txt);
			ConsoleColor consoleColor = ((loggingMode == 1) ? ConsoleColor.Yellow : ConsoleColor.Gray);
			if (Preferences.LoggingMode.Value >= loggingMode)
			{
				_logger.Msg(consoleColor, text, args);
			}
		}

		public static void Msg(ConsoleColor txtcolor, string txt, int loggingMode = 0, params object[] args)
		{
			string text = ((loggingMode == 1) ? ("[DEBUG] " + txt) : txt);
			if (Preferences.LoggingMode.Value >= loggingMode)
			{
				_logger.Msg(txtcolor, text, args);
			}
		}

		public static void Error(object obj, int loggingMode = 0)
		{
			string text = ((loggingMode == 1) ? $"[DEBUG] {obj}" : obj.ToString());
			if (Preferences.LoggingMode.Value >= loggingMode)
			{
				_logger.Error(text);
			}
		}

		public static void Error(string txt, int loggingMode = 0)
		{
			string text = ((loggingMode == 1) ? ("[DEBUG] " + txt) : txt);
			if (Preferences.LoggingMode.Value >= loggingMode)
			{
				_logger.Error(text);
			}
		}

		public static void Error(string txt, int loggingMode = 0, params object[] args)
		{
			string text = ((loggingMode == 1) ? ("[DEBUG] " + txt) : txt);
			if (Preferences.LoggingMode.Value >= loggingMode)
			{
				_logger.Error(text, args);
			}
		}

		public static void Warning(object obj, int loggingMode = 0)
		{
			string text = ((loggingMode == 1) ? $"[DEBUG] {obj}" : obj.ToString());
			if (Preferences.LoggingMode.Value >= loggingMode)
			{
				_logger.Warning(text);
			}
		}

		public static void Warning(string txt, int loggingMode = 0)
		{
			string text = ((loggingMode == 1) ? ("[DEBUG] " + txt) : txt);
			if (Preferences.LoggingMode.Value >= loggingMode)
			{
				_logger.Warning(text);
			}
		}

		public static void Warning(string txt, int loggingMode = 0, params object[] args)
		{
			string text = ((loggingMode == 1) ? ("[DEBUG] " + txt) : txt);
			if (Preferences.LoggingMode.Value >= loggingMode)
			{
				_logger.Warning(text, args);
			}
		}
	}
	internal static class Preferences
	{
		public static readonly MelonPreferences_Category GlobalCategory = MelonPreferences.CreateCategory("Global");

		public static readonly MelonPreferences_Category OwnCategory = MelonPreferences.CreateCategory("OBSControl");

		public static MelonPreferences_Entry<int> LoggingMode { get; set; }

		public static MelonPreferences_Entry<bool> ShowNotifications { get; set; }

		public static MelonPreferences_Entry<string> WebsocketURL { get; set; }

		public static MelonPreferences_Entry<string> WebsocketPassword { get; set; }

		public static MelonPreferences_Entry<ControlHand> ReplayControlHand { get; set; }

		public static MelonPreferences_Entry<float> DoubleTapTime { get; set; }

		public static void Setup()
		{
			LoggingMode = GlobalCategory.GetEntry<int>("LoggingMode") ?? GlobalCategory.CreateEntry<int>("LoggingMode", 0, "Logging Mode", "The level of logging to use. 0 = Important Only, 1 = All", false, false, (ValueValidator)null, (string)null);
			GlobalCategory.SetFilePath(MelonEnvironment.UserDataDirectory + "/WeatherElectric.cfg");
			GlobalCategory.SaveToFile(false);
			ShowNotifications = OwnCategory.CreateEntry<bool>("ShowNotifications", true, "Show Notifications", "Whether to show notifications when OBS events occur.", false, false, (ValueValidator)null, (string)null);
			WebsocketURL = OwnCategory.CreateEntry<string>("WebsocketURL", "ws://127.0.0.1:4455", "Websocket URL", "The URL to use for the websocket connection. Usually don't have to change this.", false, false, (ValueValidator)null, (string)null);
			WebsocketPassword = OwnCategory.CreateEntry<string>("WebsocketPassword", "REPLACEME", "Websocket Password", "The password to use for the websocket connection. Change this to the password you set in OBS.", false, false, (ValueValidator)null, (string)null);
			ReplayControlHand = OwnCategory.CreateEntry<ControlHand>("ReplayControlHand", ControlHand.Right, "Replay Control Hand", "The hand to use for saving replays. Left = Left hand, Right = Right hand, Both = Both hands.", false, false, (ValueValidator)null, (string)null);
			DoubleTapTime = OwnCategory.CreateEntry<float>("DoubleTapTime", 0.3f, "Double Tap Time", "The time to wait between taps to trigger saving a replay.", false, false, (ValueValidator)null, (string)null);
			OwnCategory.SetFilePath(MelonEnvironment.UserDataDirectory + "/WeatherElectric.cfg");
			OwnCategory.SaveToFile(false);
			ModConsole.Msg("Finished preferences setup for OBSControl", 1);
		}
	}
	internal enum ControlHand
	{
		Left,
		Right,
		Both
	}
}
namespace WeatherElectric.OBSControl.Handlers
{
	internal static class NotificationHandler
	{
		public static Notification SceneChanged { get; } = new Notification
		{
			Title = NotificationText.op_Implicit("Scene Changed"),
			Message = NotificationText.op_Implicit("Scene has been changed."),
			Type = (NotificationType)0,
			PopupLength = 1f,
			ShowTitleOnPopup = true
		};


		public static Notification RecordingStarted { get; } = new Notification
		{
			Title = NotificationText.op_Implicit("Recording Started"),
			Message = NotificationText.op_Implicit("Recording has started."),
			Type = (NotificationType)0,
			PopupLength = 1f,
			ShowTitleOnPopup = true
		};


		public static Notification RecordingStopped { get; } = new Notification
		{
			Title = NotificationText.op_Implicit("Recording Stopped"),
			Message = NotificationText.op_Implicit("Recording has stopped."),
			Type = (NotificationType)0,
			PopupLength = 1f,
			ShowTitleOnPopup = true
		};


		public static Notification RecordingPaused { get; } = new Notification
		{
			Title = NotificationText.op_Implicit("Recording Paused"),
			Message = NotificationText.op_Implicit("Recording has been paused."),
			Type = (NotificationType)0,
			PopupLength = 1f,
			ShowTitleOnPopup = true
		};


		public static Notification RecordingResumed { get; } = new Notification
		{
			Title = NotificationText.op_Implicit("Recording Resumed"),
			Message = NotificationText.op_Implicit("Recording has been resumed."),
			Type = (NotificationType)0,
			PopupLength = 1f,
			ShowTitleOnPopup = true
		};


		public static Notification StreamStarted { get; } = new Notification
		{
			Title = NotificationText.op_Implicit("Stream Started"),
			Message = NotificationText.op_Implicit("Stream has started."),
			Type = (NotificationType)0,
			PopupLength = 1f,
			ShowTitleOnPopup = true
		};


		public static Notification StreamStopped { get; } = new Notification
		{
			Title = NotificationText.op_Implicit("Stream Stopped"),
			Message = NotificationText.op_Implicit("Stream has stopped."),
			Type = (NotificationType)0,
			PopupLength = 1f,
			ShowTitleOnPopup = true
		};


		public static Notification ReplayBufferStarted { get; } = new Notification
		{
			Title = NotificationText.op_Implicit("Replay Buffer Started"),
			Message = NotificationText.op_Implicit("Replay buffer has started."),
			Type = (NotificationType)0,
			PopupLength = 1f,
			ShowTitleOnPopup = true
		};


		public static Notification ReplayBufferStopped { get; } = new Notification
		{
			Title = NotificationText.op_Implicit("Replay Buffer Stopped"),
			Message = NotificationText.op_Implicit("Replay buffer has stopped."),
			Type = (NotificationType)0,
			PopupLength = 1f,
			ShowTitleOnPopup = true
		};


		public static Notification ReplaySaved { get; } = new Notification
		{
			Title = NotificationText.op_Implicit("Replay Saved"),
			Message = NotificationText.op_Implicit("Replay has been saved."),
			Type = (NotificationType)0,
			PopupLength = 1f,
			ShowTitleOnPopup = true
		};


		public static void SendNotif(Notification notification)
		{
			if (Preferences.ShowNotifications.Value)
			{
				Notifier.Send(notification);
			}
		}
	}
}
namespace WeatherElectric.OBSControl.Menu
{
	internal static class BoneMenu
	{
		private static Page _subCat;

		private static FunctionElement _recordButton;

		private static FunctionElement _pauseButton;

		private static FunctionElement _streamButton;

		private static FunctionElement _replayButton;

		private static FunctionElement _connectButton;

		private static Page _scenesPanel;

		private static readonly List<FunctionElement> SceneButtons = new List<FunctionElement>();

		public static void SetupBaseMenu()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			_subCat = Page.Root.CreatePage("<color=#6FBDFF>Weather Electric</color>", Color.cyan, 0, true).CreatePage("<color=#284cb8>OBSControl</color>", Color.white, 0, true);
			_connectButton = _subCat.CreateFunction("If you see this, it failed to connect.", Color.red, (Action)delegate
			{
				Utils.ForceCrash((ForcedCrashCategory)0);
			});
		}

		public static void SetupObsControls()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_022c: Unknown result type (might be due to invalid IL or missing references)
			//IL_023e: Unknown result type (might be due to invalid IL or missing references)
			//IL_025a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0298: Unknown result type (might be due to invalid IL or missing references)
			_subCat.Remove((Element)(object)_connectButton);
			Page obj = _subCat.CreatePage("Record", Color.green, 0, true);
			_recordButton = obj.CreateFunction("Record Button", Color.green, (Action)delegate
			{
				if (ObsBridge.IsRecording())
				{
					ObsBridge.StopRecording();
					NotificationHandler.SendNotif(NotificationHandler.RecordingStopped);
				}
				else
				{
					ObsBridge.StartRecording();
					NotificationHandler.SendNotif(NotificationHandler.RecordingStarted);
				}
			});
			SetRecordButton(ObsBridge.IsRecording());
			_pauseButton = obj.CreateFunction("Pause Button", Color.yellow, (Action)delegate
			{
				if (ObsBridge.IsRecordingPaused())
				{
					ObsBridge.ResumeRecording();
					NotificationHandler.SendNotif(NotificationHandler.RecordingResumed);
				}
				else
				{
					ObsBridge.PauseRecording();
					NotificationHandler.SendNotif(NotificationHandler.RecordingPaused);
				}
			});
			SetPauseButton(ObsBridge.IsRecordingPaused());
			_streamButton = _subCat.CreatePage("Stream", Color.blue, 0, true).CreateFunction("Stream Button", Color.blue, (Action)delegate
			{
				if (ObsBridge.IsStreaming())
				{
					ObsBridge.StopStreaming();
					NotificationHandler.SendNotif(NotificationHandler.StreamStopped);
				}
				else
				{
					ObsBridge.StartStreaming();
					NotificationHandler.SendNotif(NotificationHandler.StreamStarted);
				}
			});
			SetStreamButton(ObsBridge.IsStreaming());
			Page obj2 = _subCat.CreatePage("Replay", Color.yellow, 0, true);
			_replayButton = obj2.CreateFunction("Replay Button", Color.blue, (Action)delegate
			{
				if (ObsBridge.IsReplayBufferActive())
				{
					ObsBridge.StopReplayBuffer();
					NotificationHandler.SendNotif(NotificationHandler.ReplayBufferStopped);
				}
				else
				{
					ObsBridge.StartReplayBuffer();
					NotificationHandler.SendNotif(NotificationHandler.ReplayBufferStarted);
				}
			});
			SetReplayButton(ObsBridge.IsReplayBufferActive());
			obj2.CreateFunction("Save Replay", Color.blue, (Action)delegate
			{
				ObsBridge.SaveReplayBuffer();
				NotificationHandler.SendNotif(NotificationHandler.ReplaySaved);
			});
			_scenesPanel = _subCat.CreatePage("Scenes", Color.red, 0, true);
			List<SceneBasicInfo> scenes = ObsBridge.GetScenes();
			ModConsole.Msg("Finding scenes", 1);
			foreach (SceneBasicInfo scene in scenes)
			{
				ModConsole.Msg("Found scene: " + scene.Name, 1);
				FunctionElement item = _scenesPanel.CreateFunction(scene.Name, Color.white, (Action)delegate
				{
					//IL_002a: Unknown result type (might be due to invalid IL or missing references)
					//IL_002f: Unknown result type (might be due to invalid IL or missing references)
					ObsBridge.SetScene(scene.Name);
					NotificationHandler.SceneChanged.Message = NotificationText.op_Implicit("Scene changed to " + scene.Name);
					NotificationHandler.SendNotif(NotificationHandler.SceneChanged);
				});
				SceneButtons.Add(item);
			}
			Page obj3 = _subCat.CreatePage("Settings", Color.gray, 0, true);
			obj3.CreateBoolPreference("Show Notifications", Color.white, Preferences.ShowNotifications, Preferences.OwnCategory);
			obj3.CreateEnum("Replay Control Hand", Color.white, (Enum)Preferences.ReplayControlHand.Value, (Action<Enum>)delegate(Enum v)
			{
				Preferences.ReplayControlHand.Value = (ControlHand)(object)v;
				Preferences.OwnCategory.SaveToFile(false);
			});
			obj3.CreateFloatPreference("Double Tap Time", Color.white, 0.1f, 0.1f, 1f, Preferences.DoubleTapTime, Preferences.OwnCategory);
			ConnectHooks();
		}

		private static void ConnectHooks()
		{
			ObsBridge.OnRecordStateChanged = (Action<object, RecordStateChangedEventArgs>)Delegate.Combine(ObsBridge.OnRecordStateChanged, new Action<object, RecordStateChangedEventArgs>(RecordStatusChanged));
			ObsBridge.OnStreamStateChanged = (Action<object, StreamStateChangedEventArgs>)Delegate.Combine(ObsBridge.OnStreamStateChanged, new Action<object, StreamStateChangedEventArgs>(StreamStatusChanged));
			ObsBridge.OnReplayBufferStateChanged = (Action<object, ReplayBufferStateChangedEventArgs>)Delegate.Combine(ObsBridge.OnReplayBufferStateChanged, new Action<object, ReplayBufferStateChangedEventArgs>(ReplayStatusChanged));
			ObsBridge.OnSceneCreated = (Action<object, SceneCreatedEventArgs>)Delegate.Combine(ObsBridge.OnSceneCreated, new Action<object, SceneCreatedEventArgs>(SceneCreated));
			ObsBridge.OnSceneRemoved = (Action<object, SceneRemovedEventArgs>)Delegate.Combine(ObsBridge.OnSceneRemoved, new Action<object, SceneRemovedEventArgs>(SceneDeleted));
		}

		private static void RecordStatusChanged(object sender, RecordStateChangedEventArgs e)
		{
			SetRecordButton(((OutputStateChanged)e.OutputState).IsActive);
		}

		private static void StreamStatusChanged(object sender, StreamStateChangedEventArgs e)
		{
			SetStreamButton(e.OutputState.IsActive);
		}

		private static void ReplayStatusChanged(object sender, ReplayBufferStateChangedEventArgs e)
		{
			SetReplayButton(e.OutputState.IsActive);
		}

		private static void SceneCreated(object sender, SceneCreatedEventArgs e)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			ModConsole.Msg("Scene created: " + e.SceneName, 1);
			FunctionElement item = _scenesPanel.CreateFunction(e.SceneName, Color.white, (Action)delegate
			{
				ObsBridge.SetScene(e.SceneName);
			});
			SceneButtons.Add(item);
		}

		private static void SceneDeleted(object sender, SceneRemovedEventArgs e)
		{
			ModConsole.Msg("Scene deleted: " + e.SceneName, 1);
			using IEnumerator<FunctionElement> enumerator = SceneButtons.Where((FunctionElement button) => ((Element)button).ElementName == e.SceneName).GetEnumerator();
			if (enumerator.MoveNext())
			{
				FunctionElement current = enumerator.Current;
				_scenesPanel.Remove((Element)(object)current);
				SceneButtons.Remove(current);
			}
		}

		private static void SetRecordButton(bool isRecording)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			if (isRecording)
			{
				((Element)_recordButton).ElementColor = Color.red;
				((Element)_recordButton).ElementName = "Stop Recording";
			}
			else
			{
				((Element)_recordButton).ElementColor = Color.green;
				((Element)_recordButton).ElementName = "Start Recording";
			}
		}

		private static void SetPauseButton(bool isPaused)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			if (isPaused)
			{
				((Element)_pauseButton).ElementColor = Color.white;
				((Element)_pauseButton).ElementName = "Resume Recording";
			}
			else
			{
				((Element)_pauseButton).ElementColor = Color.yellow;
				((Element)_pauseButton).ElementName = "Pause Recording";
			}
		}

		private static void SetStreamButton(bool isStreaming)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			if (isStreaming)
			{
				((Element)_streamButton).ElementColor = Color.red;
				((Element)_streamButton).ElementName = "Stop Streaming";
			}
			else
			{
				((Element)_streamButton).ElementColor = Color.green;
				((Element)_streamButton).ElementName = "Start Streaming";
			}
		}

		private static void SetReplayButton(bool isReplayActive)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			if (isReplayActive)
			{
				((Element)_replayButton).ElementColor = Color.red;
				((Element)_replayButton).ElementName = "Stop Replay Buffer";
			}
			else
			{
				((Element)_replayButton).ElementColor = Color.green;
				((Element)_replayButton).ElementName = "Start Replay Buffer";
			}
		}
	}
	internal static class BoneMenuExtensions
	{
		public static BoolElement CreateBoolPreference(this Page category, string name, Color color, MelonPreferences_Entry<bool> pref, MelonPreferences_Category prefCategory, bool autoSave = true)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			return category.CreateBool(name, color, pref.Value, (Action<bool>)delegate(bool v)
			{
				pref.Value = v;
				if (autoSave)
				{
					prefCategory.SaveToFile(false);
				}
			});
		}

		public static FloatElement CreateFloatPreference(this Page category, string name, Color color, float increment, float min, float max, MelonPreferences_Entry<float> pref, MelonPreferences_Category prefCategory, bool autoSave = true)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			return category.CreateFloat(name, color, pref.Value, increment, min, max, (Action<float>)delegate(float v)
			{
				pref.Value = v;
				if (autoSave)
				{
					prefCategory.SaveToFile(false);
				}
			});
		}

		public static IntElement CreateIntPreference(this Page category, string name, Color color, int increment, int min, int max, MelonPreferences_Entry<int> pref, MelonPreferences_Category prefCategory, bool autoSave = true)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			return category.CreateInt(name, color, pref.Value, increment, min, max, (Action<int>)delegate(int v)
			{
				pref.Value = v;
				if (autoSave)
				{
					prefCategory.SaveToFile(false);
				}
			});
		}

		public static EnumElement CreateEnumPreference(this Page category, string name, Color color, Enum pref, MelonPreferences_Category prefCategory, bool autoSave = true)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			return category.CreateEnum(name, color, pref, (Action<Enum>)delegate(Enum v)
			{
				pref = v;
				if (autoSave)
				{
					prefCategory.SaveToFile(false);
				}
			});
		}
	}
}

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Net.WebSockets;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;
using Newtonsoft.Json.Converters;
using Newtonsoft.Json.Linq;
using OBSWebsocketDotNet.Communication;
using OBSWebsocketDotNet.Types;
using OBSWebsocketDotNet.Types.Events;
using Websocket.Client;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = "")]
[assembly: AssemblyCompany("BarRaider")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Copyright © BarRaider 2022")]
[assembly: AssemblyDescription("Official obs-websocket .NET library. Written in C#. Supports .NET Standard")]
[assembly: AssemblyFileVersion("5.0.0.3")]
[assembly: AssemblyInformationalVersion("5.0.0.3")]
[assembly: AssemblyProduct("obs-websocket-dotnet")]
[assembly: AssemblyTitle("obs-websocket-dotnet")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/BarRaider/obs-websocket-dotnet")]
[assembly: AssemblyVersion("5.0.0.3")]
namespace OBSWebsocketDotNet
{
	public class OBSWebsocket : IOBSWebsocket
	{
		private delegate void RequestCallback(OBSWebsocket sender, JObject body);

		private const string WEBSOCKET_URL_PREFIX = "ws://";

		private const int SUPPORTED_RPC_VERSION = 1;

		private TimeSpan wsTimeout = TimeSpan.FromSeconds(10.0);

		private string connectionPassword;

		private WebsocketClient wsConnection;

		private readonly ConcurrentDictionary<string, TaskCompletionSource<JObject>> responseHandlers;

		private static readonly Random random = new Random();

		private const string REQUEST_FIELD_VOLUME_DB = "inputVolumeDb";

		private const string REQUEST_FIELD_VOLUME_MUL = "inputVolumeMul";

		private const string RESPONSE_FIELD_IMAGE_DATA = "imageData";

		public TimeSpan WSTimeout
		{
			get
			{
				WebsocketClient obj = wsConnection;
				return ((obj != null) ? obj.ReconnectTimeout : null) ?? wsTimeout;
			}
			set
			{
				wsTimeout = value;
				if (wsConnection != null)
				{
					wsConnection.ReconnectTimeout = wsTimeout;
				}
			}
		}

		public bool IsConnected
		{
			get
			{
				if (wsConnection != null)
				{
					return wsConnection.IsRunning;
				}
				return false;
			}
		}

		public event EventHandler<ProgramSceneChangedEventArgs> CurrentProgramSceneChanged;

		public event EventHandler<SceneListChangedEventArgs> SceneListChanged;

		public event EventHandler<SceneItemListReindexedEventArgs> SceneItemListReindexed;

		public event EventHandler<SceneItemCreatedEventArgs> SceneItemCreated;

		public event EventHandler<SceneItemRemovedEventArgs> SceneItemRemoved;

		public event EventHandler<SceneItemEnableStateChangedEventArgs> SceneItemEnableStateChanged;

		public event EventHandler<SceneItemLockStateChangedEventArgs> SceneItemLockStateChanged;

		public event EventHandler<CurrentSceneCollectionChangedEventArgs> CurrentSceneCollectionChanged;

		public event EventHandler<SceneCollectionListChangedEventArgs> SceneCollectionListChanged;

		public event EventHandler<CurrentSceneTransitionChangedEventArgs> CurrentSceneTransitionChanged;

		public event EventHandler<CurrentSceneTransitionDurationChangedEventArgs> CurrentSceneTransitionDurationChanged;

		public event EventHandler<SceneTransitionStartedEventArgs> SceneTransitionStarted;

		public event EventHandler<SceneTransitionEndedEventArgs> SceneTransitionEnded;

		public event EventHandler<SceneTransitionVideoEndedEventArgs> SceneTransitionVideoEnded;

		public event EventHandler<CurrentProfileChangedEventArgs> CurrentProfileChanged;

		public event EventHandler<ProfileListChangedEventArgs> ProfileListChanged;

		public event EventHandler<StreamStateChangedEventArgs> StreamStateChanged;

		public event EventHandler<RecordStateChangedEventArgs> RecordStateChanged;

		public event EventHandler<ReplayBufferStateChangedEventArgs> ReplayBufferStateChanged;

		public event EventHandler<CurrentPreviewSceneChangedEventArgs> CurrentPreviewSceneChanged;

		public event EventHandler<StudioModeStateChangedEventArgs> StudioModeStateChanged;

		public event EventHandler ExitStarted;

		public event EventHandler Connected;

		public event EventHandler<ObsDisconnectionInfo> Disconnected;

		public event EventHandler<SceneItemSelectedEventArgs> SceneItemSelected;

		public event EventHandler<SceneItemTransformEventArgs> SceneItemTransformChanged;

		public event EventHandler<InputAudioSyncOffsetChangedEventArgs> InputAudioSyncOffsetChanged;

		public event EventHandler<SourceFilterCreatedEventArgs> SourceFilterCreated;

		public event EventHandler<SourceFilterRemovedEventArgs> SourceFilterRemoved;

		public event EventHandler<SourceFilterListReindexedEventArgs> SourceFilterListReindexed;

		public event EventHandler<SourceFilterEnableStateChangedEventArgs> SourceFilterEnableStateChanged;

		public event EventHandler<InputMuteStateChangedEventArgs> InputMuteStateChanged;

		public event EventHandler<InputVolumeChangedEventArgs> InputVolumeChanged;

		public event EventHandler<VendorEventArgs> VendorEvent;

		public event EventHandler<MediaInputPlaybackEndedEventArgs> MediaInputPlaybackEnded;

		public event EventHandler<MediaInputPlaybackStartedEventArgs> MediaInputPlaybackStarted;

		public event EventHandler<MediaInputActionTriggeredEventArgs> MediaInputActionTriggered;

		public event EventHandler<VirtualcamStateChangedEventArgs> VirtualcamStateChanged;

		public event EventHandler<CurrentSceneCollectionChangingEventArgs> CurrentSceneCollectionChanging;

		public event EventHandler<CurrentProfileChangingEventArgs> CurrentProfileChanging;

		public event EventHandler<SourceFilterNameChangedEventArgs> SourceFilterNameChanged;

		public event EventHandler<InputCreatedEventArgs> InputCreated;

		public event EventHandler<InputRemovedEventArgs> InputRemoved;

		public event EventHandler<InputNameChangedEventArgs> InputNameChanged;

		public event EventHandler<InputActiveStateChangedEventArgs> InputActiveStateChanged;

		public event EventHandler<InputShowStateChangedEventArgs> InputShowStateChanged;

		public event EventHandler<InputAudioBalanceChangedEventArgs> InputAudioBalanceChanged;

		public event EventHandler<InputAudioTracksChangedEventArgs> InputAudioTracksChanged;

		public event EventHandler<InputAudioMonitorTypeChangedEventArgs> InputAudioMonitorTypeChanged;

		public event EventHandler<InputVolumeMetersEventArgs> InputVolumeMeters;

		public event EventHandler<ReplayBufferSavedEventArgs> ReplayBufferSaved;

		public event EventHandler<SceneCreatedEventArgs> SceneCreated;

		public event EventHandler<SceneRemovedEventArgs> SceneRemoved;

		public event EventHandler<SceneNameChangedEventArgs> SceneNameChanged;

		protected void ProcessEventType(string eventType, JObject body)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			//IL_10d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_10db: Expected O, but got Unknown
			//IL_0ce3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0cf3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0cfd: Expected O, but got Unknown
			//IL_0cfd: Expected O, but got Unknown
			//IL_0f86: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f96: Unknown result type (might be due to invalid IL or missing references)
			//IL_0fa0: Expected O, but got Unknown
			//IL_0fa0: Expected O, but got Unknown
			//IL_0bec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bf6: Expected O, but got Unknown
			body = (JObject)body["eventData"];
			switch (eventType)
			{
			case "CurrentProgramSceneChanged":
				this.CurrentProgramSceneChanged?.Invoke(this, new ProgramSceneChangedEventArgs((string)body["sceneName"]));
				break;
			case "SceneListChanged":
				this.SceneListChanged?.Invoke(this, new SceneListChangedEventArgs(JsonConvert.DeserializeObject<List<JObject>>((string)body["scenes"])));
				break;
			case "SceneItemListReindexed":
				this.SceneItemListReindexed?.Invoke(this, new SceneItemListReindexedEventArgs((string)body["sceneName"], JsonConvert.DeserializeObject<List<JObject>>((string)body["sceneItems"])));
				break;
			case "SceneItemCreated":
				this.SceneItemCreated?.Invoke(this, new SceneItemCreatedEventArgs((string)body["sceneName"], (string)body["sourceName"], (int)body["sceneItemId"], (int)body["sceneItemIndex"]));
				break;
			case "SceneItemRemoved":
				this.SceneItemRemoved?.Invoke(this, new SceneItemRemovedEventArgs((string)body["sceneName"], (string)body["sourceName"], (int)body["sceneItemId"]));
				break;
			case "SceneItemEnableStateChanged":
				this.SceneItemEnableStateChanged?.Invoke(this, new SceneItemEnableStateChangedEventArgs((string)body["sceneName"], (int)body["sceneItemId"], (bool)body["sceneItemEnabled"]));
				break;
			case "SceneItemLockStateChanged":
				this.SceneItemLockStateChanged?.Invoke(this, new SceneItemLockStateChangedEventArgs((string)body["sceneName"], (int)body["sceneItemId"], (bool)body["sceneItemLocked"]));
				break;
			case "CurrentSceneCollectionChanged":
				this.CurrentSceneCollectionChanged?.Invoke(this, new CurrentSceneCollectionChangedEventArgs((string)body["sceneCollectionName"]));
				break;
			case "SceneCollectionListChanged":
				this.SceneCollectionListChanged?.Invoke(this, new SceneCollectionListChangedEventArgs(JsonConvert.DeserializeObject<List<string>>((string)body["sceneCollections"])));
				break;
			case "CurrentSceneTransitionChanged":
				this.CurrentSceneTransitionChanged?.Invoke(this, new CurrentSceneTransitionChangedEventArgs((string)body["transitionName"]));
				break;
			case "CurrentSceneTransitionDurationChanged":
				this.CurrentSceneTransitionDurationChanged?.Invoke(this, new CurrentSceneTransitionDurationChangedEventArgs((int)body["transitionDuration"]));
				break;
			case "SceneTransitionStarted":
				this.SceneTransitionStarted?.Invoke(this, new SceneTransitionStartedEventArgs((string)body["transitionName"]));
				break;
			case "SceneTransitionEnded":
				this.SceneTransitionEnded?.Invoke(this, new SceneTransitionEndedEventArgs((string)body["transitionName"]));
				break;
			case "SceneTransitionVideoEnded":
				this.SceneTransitionVideoEnded?.Invoke(this, new SceneTransitionVideoEndedEventArgs((string)body["transitionName"]));
				break;
			case "CurrentProfileChanged":
				this.CurrentProfileChanged?.Invoke(this, new CurrentProfileChangedEventArgs((string)body["profileName"]));
				break;
			case "ProfileListChanged":
				this.ProfileListChanged?.Invoke(this, new ProfileListChangedEventArgs(JsonConvert.DeserializeObject<List<string>>((string)body["profiles"])));
				break;
			case "StreamStateChanged":
				this.StreamStateChanged?.Invoke(this, new StreamStateChangedEventArgs(new OutputStateChanged(body)));
				break;
			case "RecordStateChanged":
				this.RecordStateChanged?.Invoke(this, new RecordStateChangedEventArgs(new RecordStateChanged(body)));
				break;
			case "CurrentPreviewSceneChanged":
				this.CurrentPreviewSceneChanged?.Invoke(this, new CurrentPreviewSceneChangedEventArgs((string)body["sceneName"]));
				break;
			case "StudioModeStateChanged":
				this.StudioModeStateChanged?.Invoke(this, new StudioModeStateChangedEventArgs((bool)body["studioModeEnabled"]));
				break;
			case "ReplayBufferStateChanged":
				this.ReplayBufferStateChanged?.Invoke(this, new ReplayBufferStateChangedEventArgs(new OutputStateChanged(body)));
				break;
			case "ExitStarted":
				this.ExitStarted?.Invoke(this, EventArgs.Empty);
				break;
			case "SceneItemSelected":
				this.SceneItemSelected?.Invoke(this, new SceneItemSelectedEventArgs((string)body["sceneName"], (string)body["sceneItemId"]));
				break;
			case "SceneItemTransformChanged":
				this.SceneItemTransformChanged?.Invoke(this, new SceneItemTransformEventArgs((string)body["sceneName"], (string)body["sceneItemId"], new SceneItemTransformInfo((JObject)body["sceneItemTransform"])));
				break;
			case "InputAudioSyncOffsetChanged":
				this.InputAudioSyncOffsetChanged?.Invoke(this, new InputAudioSyncOffsetChangedEventArgs((string)body["inputName"], (int)body["inputAudioSyncOffset"]));
				break;
			case "InputMuteStateChanged":
				this.InputMuteStateChanged?.Invoke(this, new InputMuteStateChangedEventArgs((string)body["inputName"], (bool)body["inputMuted"]));
				break;
			case "InputVolumeChanged":
				this.InputVolumeChanged?.Invoke(this, new InputVolumeChangedEventArgs(new InputVolume(body)));
				break;
			case "SourceFilterCreated":
				this.SourceFilterCreated?.Invoke(this, new SourceFilterCreatedEventArgs((string)body["sourceName"], (string)body["filterName"], (string)body["filterKind"], (int)body["filterIndex"], (JObject)body["filterSettings"], (JObject)body["defaultFilterSettings"]));
				break;
			case "SourceFilterRemoved":
				this.SourceFilterRemoved?.Invoke(this, new SourceFilterRemovedEventArgs((string)body["sourceName"], (string)body["filterName"]));
				break;
			case "SourceFilterListReindexed":
				if (this.SourceFilterListReindexed != null)
				{
					List<FilterReorderItem> list = new List<FilterReorderItem>();
					JsonConvert.PopulateObject(((object)body["filters"]).ToString(), (object)list);
					this.SourceFilterListReindexed?.Invoke(this, new SourceFilterListReindexedEventArgs((string)body["sourceName"], list));
				}
				break;
			case "SourceFilterEnableStateChanged":
				this.SourceFilterEnableStateChanged?.Invoke(this, new SourceFilterEnableStateChangedEventArgs((string)body["sourceName"], (string)body["filterName"], (bool)body["filterEnabled"]));
				break;
			case "VendorEvent":
				this.VendorEvent?.Invoke(this, new VendorEventArgs((string)body["vendorName"], (string)body["eventType"], body));
				break;
			case "MediaInputPlaybackEnded":
				this.MediaInputPlaybackEnded?.Invoke(this, new MediaInputPlaybackEndedEventArgs((string)body["inputName"]));
				break;
			case "MediaInputPlaybackStarted":
				this.MediaInputPlaybackStarted?.Invoke(this, new MediaInputPlaybackStartedEventArgs((string)body["sourceName"]));
				break;
			case "MediaInputActionTriggered":
				this.MediaInputActionTriggered?.Invoke(this, new MediaInputActionTriggeredEventArgs((string)body["inputName"], (string)body["mediaAction"]));
				break;
			case "VirtualcamStateChanged":
				this.VirtualcamStateChanged?.Invoke(this, new VirtualcamStateChangedEventArgs(new OutputStateChanged(body)));
				break;
			case "CurrentSceneCollectionChanging":
				this.CurrentSceneCollectionChanging?.Invoke(this, new CurrentSceneCollectionChangingEventArgs((string)body["sceneCollectionName"]));
				break;
			case "CurrentProfileChanging":
				this.CurrentProfileChanging?.Invoke(this, new CurrentProfileChangingEventArgs((string)body["profileName"]));
				break;
			case "SourceFilterNameChanged":
				this.SourceFilterNameChanged?.Invoke(this, new SourceFilterNameChangedEventArgs((string)body["sourceName"], (string)body["oldFilterName"], (string)body["filterName"]));
				break;
			case "InputCreated":
				this.InputCreated?.Invoke(this, new InputCreatedEventArgs((string)body["inputName"], (string)body["inputKind"], (string)body["unversionedInputKind"], (JObject)body["inputSettings"], (JObject)body["defaultInputSettings"]));
				break;
			case "InputRemoved":
				this.InputRemoved?.Invoke(this, new InputRemovedEventArgs((string)body["inputName"]));
				break;
			case "InputNameChanged":
				this.InputNameChanged?.Invoke(this, new InputNameChangedEventArgs((string)body["oldInputName"], (string)body["inputName"]));
				break;
			case "InputActiveStateChanged":
				this.InputActiveStateChanged?.Invoke(this, new InputActiveStateChangedEventArgs((string)body["inputName"], (bool)body["videoActive"]));
				break;
			case "InputShowStateChanged":
				this.InputShowStateChanged?.Invoke(this, new InputShowStateChangedEventArgs((string)body["inputName"], (bool)body["videoShowing"]));
				break;
			case "InputAudioBalanceChanged":
				this.InputAudioBalanceChanged?.Invoke(this, new InputAudioBalanceChangedEventArgs((string)body["inputName"], (double)body["inputAudioBalance"]));
				break;
			case "InputAudioTracksChanged":
				this.InputAudioTracksChanged?.Invoke(this, new InputAudioTracksChangedEventArgs((string)body["inputName"], (JObject)body["inputAudioTracks"]));
				break;
			case "InputAudioMonitorTypeChanged":
				this.InputAudioMonitorTypeChanged?.Invoke(this, new InputAudioMonitorTypeChangedEventArgs((string)body["inputName"], (string)body["monitorType"]));
				break;
			case "InputVolumeMeters":
				this.InputVolumeMeters?.Invoke(this, new InputVolumeMetersEventArgs(JsonConvert.DeserializeObject<List<JObject>>((string)body["inputs"])));
				break;
			case "ReplayBufferSaved":
				this.ReplayBufferSaved?.Invoke(this, new ReplayBufferSavedEventArgs((string)body["savedReplayPath"]));
				break;
			case "SceneCreated":
				this.SceneCreated?.Invoke(this, new SceneCreatedEventArgs((string)body["sceneName"], (bool)body["isGroup"]));
				break;
			case "SceneRemoved":
				this.SceneRemoved?.Invoke(this, new SceneRemovedEventArgs((string)body["sceneName"], (bool)body["isGroup"]));
				break;
			case "SceneNameChanged":
				this.SceneNameChanged?.Invoke(this, new SceneNameChangedEventArgs((string)body["oldSceneName"], (string)body["sceneName"]));
				break;
			default:
				Console.WriteLine($"Unsupported Event: {eventType}\n{body}");
				break;
			}
		}

		public OBSWebsocket()
		{
			responseHandlers = new ConcurrentDictionary<string, TaskCompletionSource<JObject>>();
		}

		[Obsolete("Please use ConnectAsync, this function will be removed in the next version")]
		public void Connect(string url, string password)
		{
			ConnectAsync(url, password);
		}

		public void ConnectAsync(string url, string password)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Expected O, but got Unknown
			if (!url.ToLower().StartsWith("ws://"))
			{
				throw new ArgumentException("Invalid url, must start with 'ws://'");
			}
			if (wsConnection != null && wsConnection.IsRunning)
			{
				Disconnect();
			}
			wsConnection = new WebsocketClient(new Uri(url), (Func<ClientWebSocket>)null);
			wsConnection.IsReconnectionEnabled = false;
			wsConnection.ReconnectTimeout = null;
			wsConnection.ErrorReconnectTimeout = null;
			ObservableExtensions.Subscribe<ResponseMessage>(wsConnection.MessageReceived, (Action<ResponseMessage>)delegate(ResponseMessage m)
			{
				Task.Run(delegate
				{
					WebsocketMessageHandler(this, m);
				});
			});
			ObservableExtensions.Subscribe<DisconnectionInfo>(wsConnection.DisconnectionHappened, (Action<DisconnectionInfo>)delegate(DisconnectionInfo d)
			{
				Task.Run(delegate
				{
					OnWebsocketDisconnect(this, d);
				});
			});
			connectionPassword = password;
			wsConnection.StartOrFail();
		}

		public void Disconnect()
		{
			connectionPassword = null;
			if (wsConnection != null)
			{
				try
				{
					wsConnection.Stop(WebSocketCloseStatus.NormalClosure, "User requested disconnect");
					((IDisposable)wsConnection).Dispose();
				}
				catch
				{
				}
				wsConnection = null;
			}
			KeyValuePair<string, TaskCompletionSource<JObject>>[] array = responseHandlers.ToArray();
			responseHandlers.Clear();
			KeyValuePair<string, TaskCompletionSource<JObject>>[] array2 = array;
			foreach (KeyValuePair<string, TaskCompletionSource<JObject>> keyValuePair in array2)
			{
				keyValuePair.Value.TrySetCanceled();
			}
		}

		private void OnWebsocketDisconnect(object sender, DisconnectionInfo d)
		{
			if (d == null || !d.CloseStatus.HasValue)
			{
				this.Disconnected?.Invoke(sender, new ObsDisconnectionInfo(ObsCloseCodes.UnknownReason, null, d));
			}
			else
			{
				this.Disconnected?.Invoke(sender, new ObsDisconnectionInfo((ObsCloseCodes)d.CloseStatus.Value, d.CloseStatusDescription, d));
			}
		}

		private void WebsocketMessageHandler(object sender, ResponseMessage e)
		{
			if (e.MessageType != 0)
			{
				return;
			}
			ServerMessage serverMessage = JsonConvert.DeserializeObject<ServerMessage>(e.Text);
			JObject body = serverMessage.Data;
			switch (serverMessage.OperationCode)
			{
			case MessageTypes.Hello:
				HandleHello(body);
				break;
			case MessageTypes.Identified:
				Task.Run(delegate
				{
					this.Connected?.Invoke(this, EventArgs.Empty);
				});
				break;
			case MessageTypes.RequestResponse:
			case MessageTypes.RequestBatchResponse:
				if (body.ContainsKey("requestId"))
				{
					string key = (string)body["requestId"];
					if (responseHandlers.TryRemove(key, out var value))
					{
						value.SetResult(body);
					}
				}
				break;
			case MessageTypes.Event:
			{
				string eventType = ((object)body["eventType"]).ToString();
				Task.Run(delegate
				{
					ProcessEventType(eventType, body);
				});
				break;
			}
			}
		}

		public JObject SendRequest(string requestType, JObject additionalFields = null)
		{
			return SendRequest(MessageTypes.Request, requestType, additionalFields);
		}

		internal JObject SendRequest(MessageTypes operationCode, string requestType, JObject additionalFields = null, bool waitForReply = true)
		{
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Expected O, but got Unknown
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Expected O, but got Unknown
			if (wsConnection == null)
			{
				throw new NullReferenceException("Websocket is not initialized");
			}
			TaskCompletionSource<JObject> taskCompletionSource = new TaskCompletionSource<JObject>();
			JObject val = null;
			string messageId;
			do
			{
				val = MessageFactory.BuildMessage(operationCode, requestType, additionalFields, out messageId);
			}
			while (waitForReply && !responseHandlers.TryAdd(messageId, taskCompletionSource));
			wsConnection.Send(((object)val).ToString());
			if (!waitForReply)
			{
				return null;
			}
			taskCompletionSource.Task.Wait(wsTimeout.Milliseconds);
			if (taskCompletionSource.Task.IsCanceled)
			{
				throw new ErrorResponseException("Request canceled", 0);
			}
			JObject result = taskCompletionSource.Task.Result;
			if (!(bool)result["requestStatus"][(object)"result"])
			{
				JObject val2 = (JObject)result["requestStatus"];
				throw new ErrorResponseException(string.Format("ErrorCode: {0}{1}", val2["code"], val2.ContainsKey("comment") ? string.Format(", Comment: {0}", val2["comment"]) : ""), (int)val2["code"]);
			}
			if (result.ContainsKey("responseData"))
			{
				return result["responseData"].ToObject<JObject>();
			}
			return new JObject();
		}

		public OBSAuthInfo GetAuthInfo()
		{
			return new OBSAuthInfo(SendRequest("GetAuthRequired"));
		}

		protected void SendIdentify(string password, OBSAuthInfo authInfo = null)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("rpcVersion", JToken.op_Implicit(1));
			JObject val2 = val;
			if (authInfo != null)
			{
				string text = HashEncode(password + authInfo.PasswordSalt);
				string text2 = HashEncode(text + authInfo.Challenge);
				val2.Add("authentication", JToken.op_Implicit(text2));
			}
			SendRequest(MessageTypes.Identify, null, val2, waitForReply: false);
		}

		protected string HashEncode(string input)
		{
			using SHA256Managed sHA256Managed = new SHA256Managed();
			byte[] bytes = Encoding.ASCII.GetBytes(input);
			return Convert.ToBase64String(sHA256Managed.ComputeHash(bytes));
		}

		protected string NewMessageID(int length = 16)
		{
			string text = "";
			for (int i = 0; i < length; i++)
			{
				int index = random.Next(0, "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ".Length - 1);
				text += "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"[index];
			}
			return text;
		}

		private void HandleHello(JObject payload)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Expected O, but got Unknown
			if (wsConnection.IsStarted)
			{
				OBSAuthInfo authInfo = null;
				if (payload.ContainsKey("authentication"))
				{
					authInfo = new OBSAuthInfo((JObject)payload["authentication"]);
				}
				SendIdentify(connectionPassword, authInfo);
				connectionPassword = null;
			}
		}

		public ObsVideoSettings GetVideoSettings()
		{
			return JsonConvert.DeserializeObject<ObsVideoSettings>(((object)SendRequest("GetVideoSettings")).ToString());
		}

		public string SaveSourceScreenshot(string sourceName, string imageFormat, string imageFilePath, int imageWidth = -1, int imageHeight = -1, int imageCompressionQuality = -1)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("sourceName", JToken.op_Implicit(sourceName));
			val.Add("imageFormat", JToken.op_Implicit(imageFormat));
			val.Add("imageFilePath", JToken.op_Implicit(imageFilePath));
			JObject val2 = val;
			if (imageWidth > -1)
			{
				val2.Add("imageWidth", JToken.op_Implicit(imageWidth));
			}
			if (imageHeight > -1)
			{
				val2.Add("imageHeight", JToken.op_Implicit(imageHeight));
			}
			if (imageCompressionQuality > -1)
			{
				val2.Add("imageCompressionQuality", JToken.op_Implicit(imageCompressionQuality));
			}
			return (string)SendRequest("SaveSourceScreenshot", val2)["imageData"];
		}

		public string SaveSourceScreenshot(string sourceName, string imageFormat, string imageFilePath)
		{
			return SaveSourceScreenshot(sourceName, imageFormat, imageFilePath, -1, -1, -1);
		}

		public void TriggerHotkeyByName(string hotkeyName)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("hotkeyName", JToken.op_Implicit(hotkeyName));
			JObject additionalFields = val;
			SendRequest("TriggerHotkeyByName", additionalFields);
		}

		public void TriggerHotkeyByKeySequence(OBSHotkey keyId, KeyModifier keyModifier = KeyModifier.None)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Expected O, but got Unknown
			//IL_008b: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("keyId", JToken.op_Implicit(keyId.ToString()));
			JObject val2 = new JObject();
			val2.Add("shift", JToken.op_Implicit((keyModifier & KeyModifier.Shift) == KeyModifier.Shift));
			val2.Add("alt", JToken.op_Implicit((keyModifier & KeyModifier.Alt) == KeyModifier.Alt));
			val2.Add("control", JToken.op_Implicit((keyModifier & KeyModifier.Control) == KeyModifier.Control));
			val2.Add("command", JToken.op_Implicit((keyModifier & KeyModifier.Command) == KeyModifier.Command));
			val.Add("keyModifiers", (JToken)val2);
			JObject additionalFields = val;
			SendRequest("TriggerHotkeyByKeySequence", additionalFields);
		}

		public string GetCurrentProgramScene()
		{
			return (string)SendRequest("GetCurrentProgramScene")["currentProgramSceneName"];
		}

		public void SetCurrentProgramScene(string sceneName)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("sceneName", JToken.op_Implicit(sceneName));
			JObject additionalFields = val;
			SendRequest("SetCurrentProgramScene", additionalFields);
		}

		public ObsStats GetStats()
		{
			return JsonConvert.DeserializeObject<ObsStats>(((object)SendRequest("GetStats")).ToString());
		}

		public List<SceneBasicInfo> ListScenes()
		{
			return GetSceneList().Scenes;
		}

		public GetSceneListInfo GetSceneList()
		{
			return JsonConvert.DeserializeObject<GetSceneListInfo>(((object)SendRequest("GetSceneList")).ToString());
		}

		public TransitionOverrideInfo GetSceneSceneTransitionOverride(string sceneName)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("sceneName", JToken.op_Implicit(sceneName));
			JObject additionalFields = val;
			return ((JToken)SendRequest("GetSceneSceneTransitionOverride", additionalFields)).ToObject<TransitionOverrideInfo>();
		}

		public void SetSceneSceneTransitionOverride(string sceneName, string transitionName, int transitionDuration = -1)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("sceneName", JToken.op_Implicit(sceneName));
			val.Add("transitionName", JToken.op_Implicit(transitionName));
			JObject val2 = val;
			if (transitionDuration >= 0)
			{
				val2.Add("transitionDuration", JToken.op_Implicit(transitionDuration));
			}
			SendRequest("SetSceneSceneTransitionOverride", val2);
		}

		public void SetTBarPosition(double position, bool release = true)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			if (position < 0.0 || position > 1.0)
			{
				throw new ArgumentOutOfRangeException("position");
			}
			JObject val = new JObject();
			val.Add("position", JToken.op_Implicit(position));
			val.Add("release", JToken.op_Implicit(release));
			JObject additionalFields = val;
			SendRequest("SetTBarPosition", additionalFields);
		}

		public void SetSourceFilterSettings(string sourceName, string filterName, JObject filterSettings, bool overlay = false)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("sourceName", JToken.op_Implicit(sourceName));
			val.Add("filterName", JToken.op_Implicit(filterName));
			val.Add("filterSettings", (JToken)(object)filterSettings);
			val.Add("overlay", JToken.op_Implicit(overlay));
			JObject additionalFields = val;
			SendRequest("SetSourceFilterSettings", additionalFields);
		}

		public void SetSourceFilterSettings(string sourceName, string filterName, FilterSettings filterSettings, bool overlay = false)
		{
			SetSourceFilterSettings(sourceName, filterName, JObject.FromObject((object)filterSettings), overlay);
		}

		public void SetSourceFilterEnabled(string sourceName, string filterName, bool filterEnabled)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("sourceName", JToken.op_Implicit(sourceName));
			val.Add("filterName", JToken.op_Implicit(filterName));
			val.Add("filterEnabled", JToken.op_Implicit(filterEnabled));
			JObject additionalFields = val;
			SendRequest("SetSourceFilterEnabled", additionalFields);
		}

		public List<FilterSettings> GetSourceFilterList(string sourceName)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("sourceName", JToken.op_Implicit(sourceName));
			JObject additionalFields = val;
			JObject val2 = SendRequest("GetSourceFilterList", additionalFields);
			if (!((JToken)val2).HasValues)
			{
				return new List<FilterSettings>();
			}
			return JsonConvert.DeserializeObject<List<FilterSettings>>(((object)val2["filters"]).ToString());
		}

		public FilterSettings GetSourceFilter(string sourceName, string filterName)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("sourceName", JToken.op_Implicit(sourceName));
			val.Add("filterName", JToken.op_Implicit(filterName));
			JObject additionalFields = val;
			return JsonConvert.DeserializeObject<FilterSettings>(((object)SendRequest("GetSourceFilter", additionalFields)).ToString());
		}

		public bool RemoveSourceFilter(string sourceName, string filterName)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("sourceName", JToken.op_Implicit(sourceName));
			val.Add("filterName", JToken.op_Implicit(filterName));
			JObject additionalFields = val;
			try
			{
				SendRequest("RemoveSourceFilter", additionalFields);
				return true;
			}
			catch (Exception ex)
			{
				Console.WriteLine(ex.Message);
			}
			return false;
		}

		public void CreateSourceFilter(string sourceName, string filterName, string filterKind, JObject filterSettings)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("sourceName", JToken.op_Implicit(sourceName));
			val.Add("filterName", JToken.op_Implicit(filterName));
			val.Add("filterKind", JToken.op_Implicit(filterKind));
			val.Add("filterSettings", (JToken)(object)filterSettings);
			JObject additionalFields = val;
			SendRequest("CreateSourceFilter", additionalFields);
		}

		public void CreateSourceFilter(string sourceName, string filterName, string filterKind, FilterSettings filterSettings)
		{
			CreateSourceFilter(sourceName, filterName, filterKind, JObject.FromObject((object)filterSettings));
		}

		public bool ToggleStream()
		{
			return (bool)SendRequest("ToggleStream")["outputActive"];
		}

		public void ToggleRecord()
		{
			SendRequest("ToggleRecord");
		}

		public OutputStatus GetStreamStatus()
		{
			return new OutputStatus(SendRequest("GetStreamStatus"));
		}

		public TransitionSettings GetCurrentSceneTransition()
		{
			return new TransitionSettings(SendRequest("GetCurrentSceneTransition"));
		}

		public void SetCurrentSceneTransition(string transitionName)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("transitionName", JToken.op_Implicit(transitionName));
			JObject additionalFields = val;
			SendRequest("SetCurrentSceneTransition", additionalFields);
		}

		public void SetCurrentSceneTransitionDuration(int transitionDuration)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("transitionDuration", JToken.op_Implicit(transitionDuration));
			JObject additionalFields = val;
			SendRequest("SetCurrentSceneTransitionDuration", additionalFields);
		}

		public void SetCurrentSceneTransitionSettings(JObject transitionSettings, bool overlay)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("transitionSettings", JToken.FromObject((object)transitionSettings));
			val.Add("overlay", JToken.op_Implicit(overlay));
			JObject additionalFields = val;
			SendRequest("SetCurrentSceneTransitionSettings", additionalFields);
		}

		public void SetInputVolume(string inputName, float inputVolume, bool inputVolumeDb = false)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("inputName", JToken.op_Implicit(inputName));
			JObject val2 = val;
			if (inputVolumeDb)
			{
				val2.Add("inputVolumeDb", JToken.op_Implicit(inputVolume));
			}
			else
			{
				val2.Add("inputVolumeMul", JToken.op_Implicit(inputVolume));
			}
			SendRequest("SetInputVolume", val2);
		}

		public VolumeInfo GetInputVolume(string inputName)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("inputName", JToken.op_Implicit(inputName));
			JObject additionalFields = val;
			return new VolumeInfo(SendRequest("GetInputVolume", additionalFields));
		}

		public bool GetInputMute(string inputName)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("inputName", JToken.op_Implicit(inputName));
			JObject additionalFields = val;
			return (bool)SendRequest("GetInputMute", additionalFields)["inputMuted"];
		}

		public void SetInputMute(string inputName, bool inputMuted)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("inputName", JToken.op_Implicit(inputName));
			val.Add("inputMuted", JToken.op_Implicit(inputMuted));
			JObject additionalFields = val;
			SendRequest("SetInputMute", additionalFields);
		}

		public void ToggleInputMute(string inputName)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("inputName", JToken.op_Implicit(inputName));
			JObject additionalFields = val;
			SendRequest("ToggleInputMute", additionalFields);
		}

		public void SetSceneItemTransform(string sceneName, int sceneItemId, JObject sceneItemTransform)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("sceneName", JToken.op_Implicit(sceneName));
			val.Add("sceneItemId", JToken.op_Implicit(sceneItemId));
			val.Add("sceneItemTransform", (JToken)(object)sceneItemTransform);
			JObject additionalFields = val;
			SendRequest("SetSceneItemTransform", additionalFields);
		}

		public void SetSceneItemTransform(string sceneName, int sceneItemId, SceneItemTransformInfo sceneItemTransform)
		{
			SetSceneItemTransform(sceneName, sceneItemId, JObject.FromObject((object)sceneItemTransform));
		}

		public void SetCurrentSceneCollection(string sceneCollectionName)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("sceneCollectionName", JToken.op_Implicit(sceneCollectionName));
			JObject additionalFields = val;
			SendRequest("SetCurrentSceneCollection", additionalFields);
		}

		public string GetCurrentSceneCollection()
		{
			return (string)SendRequest("GetSceneCollectionList")["currentSceneCollectionName"];
		}

		public List<string> GetSceneCollectionList()
		{
			return JsonConvert.DeserializeObject<List<string>>(((object)SendRequest("GetSceneCollectionList")["sceneCollections"]).ToString());
		}

		public void SetCurrentProfile(string profileName)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("profileName", JToken.op_Implicit(profileName));
			JObject additionalFields = val;
			SendRequest("SetCurrentProfile", additionalFields);
		}

		public GetProfileListInfo GetProfileList()
		{
			return JsonConvert.DeserializeObject<GetProfileListInfo>(((object)SendRequest("GetProfileList")).ToString());
		}

		public void StartStream()
		{
			SendRequest("StartStream");
		}

		public void StopStream()
		{
			SendRequest("StopStream");
		}

		public void StartRecord()
		{
			SendRequest("StartRecord");
		}

		public string StopRecord()
		{
			return (string)SendRequest("StopRecord")["outputPath"];
		}

		public void PauseRecord()
		{
			SendRequest("PauseRecord");
		}

		public void ResumeRecord()
		{
			SendRequest("ResumeRecord");
		}

		public string GetRecordDirectory()
		{
			return (string)SendRequest("GetRecordDirectory")["recordDirectory"];
		}

		public RecordingStatus GetRecordStatus()
		{
			return JsonConvert.DeserializeObject<RecordingStatus>(((object)SendRequest("GetRecordStatus")).ToString());
		}

		public bool GetReplayBufferStatus()
		{
			return (bool)SendRequest("GetReplayBufferStatus")["outputActive"];
		}

		public GetTransitionListInfo GetSceneTransitionList()
		{
			return JsonConvert.DeserializeObject<GetTransitionListInfo>(((object)SendRequest("GetSceneTransitionList")).ToString());
		}

		public bool GetStudioModeEnabled()
		{
			return (bool)SendRequest("GetStudioModeEnabled")["studioModeEnabled"];
		}

		public void SetStudioModeEnabled(bool studioModeEnabled)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("studioModeEnabled", JToken.op_Implicit(studioModeEnabled));
			JObject additionalFields = val;
			SendRequest("SetStudioModeEnabled", additionalFields);
		}

		public string GetCurrentPreviewScene()
		{
			return (string)SendRequest("GetCurrentPreviewScene")["currentPreviewSceneName"];
		}

		public void SetCurrentPreviewScene(string sceneName)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("sceneName", JToken.op_Implicit(sceneName));
			JObject additionalFields = val;
			SendRequest("SetCurrentPreviewScene", additionalFields);
		}

		public void SetCurrentPreviewScene(ObsScene previewScene)
		{
			SetCurrentPreviewScene(previewScene.Name);
		}

		public void TriggerStudioModeTransition()
		{
			SendRequest("TriggerStudioModeTransition");
		}

		public void ToggleReplayBuffer()
		{
			SendRequest("ToggleReplayBuffer");
		}

		public void StartReplayBuffer()
		{
			SendRequest("StartReplayBuffer");
		}

		public void StopReplayBuffer()
		{
			SendRequest("StopReplayBuffer");
		}

		public void SaveReplayBuffer()
		{
			SendRequest("SaveReplayBuffer");
		}

		public void SetInputAudioSyncOffset(string inputName, int inputAudioSyncOffset)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("inputName", JToken.op_Implicit(inputName));
			val.Add("inputAudioSyncOffset", JToken.op_Implicit(inputAudioSyncOffset));
			JObject additionalFields = val;
			SendRequest("SetInputAudioSyncOffset", additionalFields);
		}

		public int GetInputAudioSyncOffset(string inputName)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("inputName", JToken.op_Implicit(inputName));
			JObject additionalFields = val;
			return (int)SendRequest("GetInputAudioSyncOffset", additionalFields)["inputAudioSyncOffset"];
		}

		public void RemoveSceneItem(string sceneName, int sceneItemId)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("sceneName", JToken.op_Implicit(sceneName));
			val.Add("sceneItemId", JToken.op_Implicit(sceneItemId));
			JObject additionalFields = val;
			SendRequest("RemoveSceneItem", additionalFields);
		}

		public void SendStreamCaption(string captionText)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("captionText", JToken.op_Implicit(captionText));
			JObject additionalFields = val;
			SendRequest("SendStreamCaption", additionalFields);
		}

		public void DuplicateSceneItem(string sceneName, int sceneItemId, string destinationSceneName = null)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("sceneName", JToken.op_Implicit(sceneName));
			val.Add("sceneItemId", JToken.op_Implicit(sceneItemId));
			JObject val2 = val;
			if (!string.IsNullOrEmpty(destinationSceneName))
			{
				val2.Add("destinationSceneName", JToken.op_Implicit(destinationSceneName));
			}
			SendRequest("DuplicateSceneItem", val2);
		}

		public Dictionary<string, string> GetSpecialInputs()
		{
			JObject obj = SendRequest("GetSpecialInputs");
			Dictionary<string, string> dictionary = new Dictionary<string, string>();
			foreach (KeyValuePair<string, JToken> item in obj)
			{
				string key = item.Key;
				string value = (string)item.Value;
				if (key != "requestType")
				{
					dictionary.Add(key, value);
				}
			}
			return dictionary;
		}

		public void SetStreamServiceSettings(StreamingService service)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("streamServiceType", JToken.op_Implicit(service.Type));
			val.Add("streamServiceSettings", JToken.FromObject((object)service.Settings));
			JObject additionalFields = val;
			SendRequest("SetStreamServiceSettings", additionalFields);
		}

		public StreamingService GetStreamServiceSettings()
		{
			return JsonConvert.DeserializeObject<StreamingService>(((object)SendRequest("GetStreamServiceSettings")).ToString());
		}

		public string GetInputAudioMonitorType(string inputName)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("inputName", JToken.op_Implicit(inputName));
			JObject additionalFields = val;
			return (string)SendRequest("GetInputAudioMonitorType", additionalFields)["monitorType"];
		}

		public void SetInputAudioMonitorType(string inputName, string monitorType)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("inputName", JToken.op_Implicit(inputName));
			val.Add("monitorType", JToken.op_Implicit(monitorType));
			JObject additionalFields = val;
			SendRequest("SetInputAudioMonitorType", additionalFields);
		}

		public void BroadcastCustomEvent(JObject eventData)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("eventData", (JToken)(object)eventData);
			JObject additionalFields = val;
			SendRequest("BroadcastCustomEvent", additionalFields);
		}

		public void SetMediaInputCursor(string inputName, int mediaCursor)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("inputName", JToken.op_Implicit(inputName));
			val.Add("mediaCursor", JToken.op_Implicit(mediaCursor));
			JObject additionalFields = val;
			SendRequest("SetMediaInputCursor", additionalFields);
		}

		public void OffsetMediaInputCursor(string inputName, int mediaCursorOffset)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("inputName", JToken.op_Implicit(inputName));
			val.Add("mediaCursorOffset", JToken.op_Implicit(mediaCursorOffset));
			JObject additionalFields = val;
			SendRequest("OffsetMediaInputCursor", additionalFields);
		}

		public int CreateInput(string sceneName, string inputName, string inputKind, JObject inputSettings, bool? sceneItemEnabled)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("sceneName", JToken.op_Implicit(sceneName));
			val.Add("inputName", JToken.op_Implicit(inputName));
			val.Add("inputKind", JToken.op_Implicit(inputKind));
			JObject val2 = val;
			if (inputSettings != null)
			{
				val2.Add("inputSettings", (JToken)(object)inputSettings);
			}
			if (sceneItemEnabled.HasValue)
			{
				val2.Add("sceneItemEnabled", JToken.op_Implicit(sceneItemEnabled.Value));
			}
			return (int)SendRequest("CreateInput", val2)["sceneItemId"];
		}

		public JObject GetInputDefaultSettings(string inputKind)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("inputKind", JToken.op_Implicit(inputKind));
			JObject additionalFields = val;
			return (JObject)SendRequest("GetInputDefaultSettings", additionalFields)["defaultInputSettings"];
		}

		public List<SceneItemDetails> GetSceneItemList(string sceneName)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			JObject additionalFields = null;
			if (!string.IsNullOrEmpty(sceneName))
			{
				JObject val = new JObject();
				val.Add("sceneName", JToken.op_Implicit(sceneName));
				additionalFields = val;
			}
			return ((IEnumerable<JToken>)SendRequest("GetSceneItemList", additionalFields)["sceneItems"]).Select((JToken m) => new SceneItemDetails((JObject)m)).ToList();
		}

		public int CreateSceneItem(string sceneName, string sourceName, bool sceneItemEnabled = true)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("sceneName", JToken.op_Implicit(sceneName));
			val.Add("sourceName", JToken.op_Implicit(sourceName));
			val.Add("sceneItemEnabled", JToken.op_Implicit(sceneItemEnabled));
			JObject additionalFields = val;
			return (int)SendRequest("CreateSceneItem", additionalFields)["sceneItemId"];
		}

		public void CreateScene(string sceneName)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("sceneName", JToken.op_Implicit(sceneName));
			JObject additionalFields = val;
			SendRequest("CreateScene", additionalFields);
		}

		public SourceTracks GetInputAudioTracks(string inputName)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("inputName", JToken.op_Implicit(inputName));
			JObject additionalFields = val;
			return new SourceTracks(SendRequest("GetInputAudioTracks", additionalFields));
		}

		public void SetInputAudioTracks(string inputName, JObject inputAudioTracks)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("inputName", JToken.op_Implicit(inputName));
			val.Add("inputAudioTracks", (JToken)(object)inputAudioTracks);
			JObject additionalFields = val;
			SendRequest("SetInputAudioTracks", additionalFields);
		}

		public void SetInputAudioTracks(string inputName, SourceTracks inputAudioTracks)
		{
			SetInputAudioTracks(inputName, JObject.FromObject((object)inputAudioTracks));
		}

		public SourceActiveInfo GetSourceActive(string sourceName)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("sourceName", JToken.op_Implicit(sourceName));
			JObject additionalFields = val;
			return new SourceActiveInfo(SendRequest("GetSourceActive", additionalFields));
		}

		public VirtualCamStatus GetVirtualCamStatus()
		{
			return new VirtualCamStatus(SendRequest("GetVirtualCamStatus"));
		}

		public void StartVirtualCam()
		{
			SendRequest("StartVirtualCam");
		}

		public void StopVirtualCam()
		{
			SendRequest("StopVirtualCam");
		}

		public VirtualCamStatus ToggleVirtualCam()
		{
			return new VirtualCamStatus(SendRequest("ToggleVirtualCam"));
		}

		public JObject GetPersistentData(string realm, string slotName)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("realm", JToken.op_Implicit(realm));
			val.Add("slotName", JToken.op_Implicit(slotName));
			JObject additionalFields = val;
			return SendRequest("GetPersistentData", additionalFields);
		}

		public void SetPersistentData(string realm, string slotName, JObject slotValue)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("realm", JToken.op_Implicit(realm));
			val.Add("slotName", JToken.op_Implicit(slotName));
			val.Add("slotValue", (JToken)(object)slotValue);
			JObject additionalFields = val;
			SendRequest("SetPersistentData", additionalFields);
		}

		public void CreateSceneCollection(string sceneCollectionName)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("sceneCollectionName", JToken.op_Implicit(sceneCollectionName));
			JObject additionalFields = val;
			SendRequest("CreateSceneCollection", additionalFields);
		}

		public void CreateProfile(string profileName)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("profileName", JToken.op_Implicit(profileName));
			JObject additionalFields = val;
			SendRequest("CreateProfile", additionalFields);
		}

		public void RemoveProfile(string profileName)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("profileName", JToken.op_Implicit(profileName));
			JObject additionalFields = val;
			SendRequest("RemoveProfile", additionalFields);
		}

		public JObject GetProfileParameter(string parameterCategory, string parameterName)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("parameterCategory", JToken.op_Implicit(parameterCategory));
			val.Add("parameterName", JToken.op_Implicit(parameterName));
			JObject additionalFields = val;
			return SendRequest("GetProfileParameter", additionalFields);
		}

		public void SetProfileParameter(string parameterCategory, string parameterName, string parameterValue)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("parameterCategory", JToken.op_Implicit(parameterCategory));
			val.Add("parameterName", JToken.op_Implicit(parameterName));
			val.Add("parameterValue", JToken.op_Implicit(parameterValue));
			JObject additionalFields = val;
			SendRequest("SetProfileParameter", additionalFields);
		}

		public void SetVideoSettings(ObsVideoSettings obsVideoSettings)
		{
			SendRequest("SetVideoSettings", JObject.FromObject((object)obsVideoSettings));
		}

		public JObject GetSourceFilterDefaultSettings(string filterKind)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("filterKind", JToken.op_Implicit(filterKind));
			JObject additionalFields = val;
			return SendRequest("GetSourceFilterDefaultSettings", additionalFields);
		}

		public void SetSourceFilterName(string sourceName, string filterName, string newFilterName)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("sourceName", JToken.op_Implicit(sourceName));
			val.Add("filterName", JToken.op_Implicit(filterName));
			val.Add("newFilterName", JToken.op_Implicit(newFilterName));
			JObject additionalFields = val;
			SendRequest("SetSourceFilterName", additionalFields);
		}

		public void SetSourceFilterIndex(string sourceName, string filterName, int filterIndex)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("sourceName", JToken.op_Implicit(sourceName));
			val.Add("filterName", JToken.op_Implicit(filterName));
			val.Add("filterIndex", JToken.op_Implicit(filterIndex));
			JObject additionalFields = val;
			SendRequest("SetSourceFilterIndex", additionalFields);
		}

		public ObsVersion GetVersion()
		{
			return new ObsVersion(SendRequest("GetVersion"));
		}

		public JObject CallVendorRequest(string vendorName, string requestType, JObject requestData = null)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("vendorName", JToken.op_Implicit(vendorName));
			val.Add("requestType", JToken.op_Implicit(requestType));
			val.Add("requestData", (JToken)(object)requestData);
			JObject additionalFields = val;
			return SendRequest("CallVendorRequest", additionalFields);
		}

		public List<string> GetHotkeyList()
		{
			return JsonConvert.DeserializeObject<List<string>>(((object)SendRequest("GetHotkeyList")["hotkeys"]).ToString());
		}

		public void Sleep(int sleepMillis, int sleepFrames)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("sleepMillis", JToken.op_Implicit(sleepMillis));
			val.Add("sleepFrames", JToken.op_Implicit(sleepFrames));
			JObject additionalFields = val;
			SendRequest("Sleep", additionalFields);
		}

		public List<InputBasicInfo> GetInputList(string inputKind = null)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("inputKind", JToken.op_Implicit(inputKind));
			JObject additionalFields = val;
			JObject obj = ((inputKind == null) ? SendRequest("GetInputList") : SendRequest("GetInputList", additionalFields));
			List<InputBasicInfo> list = new List<InputBasicInfo>();
			foreach (JToken item in (IEnumerable<JToken>)obj["inputs"])
			{
				list.Add(new InputBasicInfo((JObject)(object)((item is JObject) ? item : null)));
			}
			return list;
		}

		public List<string> GetInputKindList(bool unversioned = false)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("unversioned", JToken.op_Implicit(unversioned));
			JObject additionalFields = val;
			return JsonConvert.DeserializeObject<List<string>>(((object)((!unversioned) ? SendRequest("GetInputKindList") : SendRequest("GetInputKindList", additionalFields))["inputKinds"]).ToString());
		}

		public void RemoveInput(string inputName)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("inputName", JToken.op_Implicit(inputName));
			JObject additionalFields = val;
			SendRequest("RemoveInput", additionalFields);
		}

		public void SetInputName(string inputName, string newInputName)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("inputName", JToken.op_Implicit(inputName));
			val.Add("newInputName", JToken.op_Implicit(newInputName));
			JObject additionalFields = val;
			SendRequest("SetInputName", additionalFields);
		}

		public InputSettings GetInputSettings(string inputName)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("inputName", JToken.op_Implicit(inputName));
			JObject val2 = val;
			JObject obj = SendRequest("GetInputSettings", val2);
			((JContainer)obj).Merge((object)val2);
			return new InputSettings(obj);
		}

		public void SetInputSettings(InputSettings inputSettings, bool overlay = true)
		{
			SetInputSettings(inputSettings.InputName, inputSettings.Settings, overlay);
		}

		public void SetInputSettings(string inputName, JObject inputSettings, bool overlay = true)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("inputName", JToken.op_Implicit(inputName));
			val.Add("inputSettings", (JToken)(object)inputSettings);
			val.Add("overlay", JToken.op_Implicit(overlay));
			JObject additionalFields = val;
			SendRequest("SetInputSettings", additionalFields);
		}

		public double GetInputAudioBalance(string inputName)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("inputName", JToken.op_Implicit(inputName));
			JObject additionalFields = val;
			return (double)SendRequest("GetInputAudioBalance", additionalFields)["inputAudioBalance"];
		}

		public void SetInputAudioBalance(string inputName, double inputAudioBalance)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("inputName", JToken.op_Implicit(inputName));
			val.Add("inputAudioBalance", JToken.op_Implicit(inputAudioBalance));
			JObject additionalFields = val;
			SendRequest("SetInputAudioBalance", additionalFields);
		}

		public List<JObject> GetInputPropertiesListPropertyItems(string inputName, string propertyName)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("inputName", JToken.op_Implicit(inputName));
			val.Add("propertyName", JToken.op_Implicit(propertyName));
			JObject additionalFields = val;
			return Extensions.Value<List<JObject>>((IEnumerable<JToken>)SendRequest("GetInputPropertiesListPropertyItems", additionalFields)["propertyItems"]);
		}

		public void PressInputPropertiesButton(string inputName, string propertyName)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("inputName", JToken.op_Implicit(inputName));
			val.Add("propertyName", JToken.op_Implicit(propertyName));
			JObject additionalFields = val;
			SendRequest("PressInputPropertiesButton", additionalFields);
		}

		public MediaInputStatus GetMediaInputStatus(string inputName)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("inputName", JToken.op_Implicit(inputName));
			JObject additionalFields = val;
			return new MediaInputStatus(SendRequest("GetMediaInputStatus", additionalFields));
		}

		public void TriggerMediaInputAction(string inputName, string mediaAction)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("inputName", JToken.op_Implicit(inputName));
			val.Add("mediaAction", JToken.op_Implicit(mediaAction));
			JObject additionalFields = val;
			SendRequest("TriggerMediaInputAction", additionalFields);
		}

		public string GetLastReplayBufferReplay()
		{
			return (string)SendRequest("GetLastReplayBufferReplay")["savedReplayPath"];
		}

		public void ToggleRecordPause()
		{
			SendRequest("ToggleRecordPause");
		}

		public List<JObject> GetGroupSceneItemList(string sceneName)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("sceneName", JToken.op_Implicit(sceneName));
			JObject additionalFields = val;
			return JsonConvert.DeserializeObject<List<JObject>>((string)SendRequest("GetGroupSceneItemList", additionalFields)["sceneItems"]);
		}

		public int GetSceneItemId(string sceneName, string sourceName, int searchOffset)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("sceneName", JToken.op_Implicit(sceneName));
			val.Add("sourceName", JToken.op_Implicit(sourceName));
			val.Add("searchOffset", JToken.op_Implicit(searchOffset));
			JObject additionalFields = val;
			return (int)SendRequest("GetSceneItemId", additionalFields)["sceneItemId"];
		}

		public SceneItemTransformInfo GetSceneItemTransform(string sceneName, int sceneItemId)
		{
			return JsonConvert.DeserializeObject<SceneItemTransformInfo>(((object)GetSceneItemTransformRaw(sceneName, sceneItemId)["sceneItemTransform"]).ToString());
		}

		public JObject GetSceneItemTransformRaw(string sceneName, int sceneItemId)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("sceneName", JToken.op_Implicit(sceneName));
			val.Add("sceneItemId", JToken.op_Implicit(sceneItemId));
			JObject additionalFields = val;
			return SendRequest("GetSceneItemTransform", additionalFields);
		}

		public bool GetSceneItemEnabled(string sceneName, int sceneItemId)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("sceneName", JToken.op_Implicit(sceneName));
			val.Add("sceneItemId", JToken.op_Implicit(sceneItemId));
			JObject additionalFields = val;
			return (bool)SendRequest("GetSceneItemEnabled", additionalFields)["sceneItemEnabled"];
		}

		public void SetSceneItemEnabled(string sceneName, int sceneItemId, bool sceneItemEnabled)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("sceneName", JToken.op_Implicit(sceneName));
			val.Add("sceneItemId", JToken.op_Implicit(sceneItemId));
			val.Add("sceneItemEnabled", JToken.op_Implicit(sceneItemEnabled));
			JObject additionalFields = val;
			SendRequest("SetSceneItemEnabled", additionalFields);
		}

		public bool GetSceneItemLocked(string sceneName, int sceneItemId)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("sceneName", JToken.op_Implicit(sceneName));
			val.Add("sceneItemId", JToken.op_Implicit(sceneItemId));
			JObject additionalFields = val;
			return (bool)SendRequest("GetSceneItemLocked", additionalFields)["sceneItemLocked"];
		}

		public void SetSceneItemLocked(string sceneName, int sceneItemId, bool sceneItemLocked)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("sceneName", JToken.op_Implicit(sceneName));
			val.Add("sceneItemId", JToken.op_Implicit(sceneItemId));
			val.Add("sceneItemLocked", JToken.op_Implicit(sceneItemLocked));
			JObject additionalFields = val;
			SendRequest("SetSceneItemLocked", additionalFields);
		}

		public int GetSceneItemIndex(string sceneName, int sceneItemId)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("sceneName", JToken.op_Implicit(sceneName));
			val.Add("sceneItemId", JToken.op_Implicit(sceneItemId));
			JObject additionalFields = val;
			return (int)SendRequest("GetSceneItemIndex", additionalFields)["sceneItemIndex"];
		}

		public void SetSceneItemIndex(string sceneName, int sceneItemId, int sceneItemIndex)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("sceneName", JToken.op_Implicit(sceneName));
			val.Add("sceneItemId", JToken.op_Implicit(sceneItemId));
			val.Add("sceneItemIndex", JToken.op_Implicit(sceneItemIndex));
			JObject additionalFields = val;
			SendRequest("SetSceneItemIndex", additionalFields);
		}

		public string GetSceneItemBlendMode(string sceneName, int sceneItemId)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("sceneName", JToken.op_Implicit(sceneName));
			val.Add("sceneItemId", JToken.op_Implicit(sceneItemId));
			JObject additionalFields = val;
			return (string)SendRequest("GetSceneItemBlendMode", additionalFields)["sceneItemBlendMode"];
		}

		public void SetSceneItemBlendMode(string sceneName, int sceneItemId, string sceneItemBlendMode)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("sceneName", JToken.op_Implicit(sceneName));
			val.Add("sceneItemId", JToken.op_Implicit(sceneItemId));
			val.Add("sceneItemBlendMode", JToken.op_Implicit(sceneItemBlendMode));
			JObject additionalFields = val;
			SendRequest("SetSceneItemBlendMode", additionalFields);
		}

		public List<string> GetGroupList()
		{
			return JsonConvert.DeserializeObject<List<string>>(((object)SendRequest("GetGroupList")["groups"]).ToString());
		}

		public void RemoveScene(string sceneName)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("sceneName", JToken.op_Implicit(sceneName));
			JObject additionalFields = val;
			SendRequest("RemoveScene", additionalFields);
		}

		public void SetSceneName(string sceneName, string newSceneName)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("sceneName", JToken.op_Implicit(sceneName));
			val.Add("newSceneName", JToken.op_Implicit(newSceneName));
			JObject additionalFields = val;
			SendRequest("SetSceneName", additionalFields);
		}

		public string GetSourceScreenshot(string sourceName, string imageFormat, int imageWidth = -1, int imageHeight = -1, int imageCompressionQuality = -1)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("sourceName", JToken.op_Implicit(sourceName));
			val.Add("imageFormat", JToken.op_Implicit(imageFormat));
			JObject val2 = val;
			if (imageWidth > -1)
			{
				val2.Add("imageWidth", JToken.op_Implicit(imageWidth));
			}
			if (imageHeight > -1)
			{
				val2.Add("imageHeight", JToken.op_Implicit(imageHeight));
			}
			if (imageCompressionQuality > -1)
			{
				val2.Add("imageCompressionQuality", JToken.op_Implicit(imageCompressionQuality));
			}
			return (string)SendRequest("GetSourceScreenshot", val2)["imageData"];
		}

		public List<string> GetTransitionKindList()
		{
			return JsonConvert.DeserializeObject<List<string>>(((object)SendRequest("GetTransitionKindList")["transitionKinds"]).ToString());
		}

		public double GetCurrentSceneTransitionCursor()
		{
			return (double)SendRequest("GetCurrentSceneTransitionCursor")["transitionCursor"];
		}

		public void OpenInputPropertiesDialog(string inputName)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("inputName", JToken.op_Implicit(inputName));
			JObject additionalFields = val;
			SendRequest("OpenInputPropertiesDialog", additionalFields);
		}

		public void OpenInputFiltersDialog(string inputName)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("inputName", JToken.op_Implicit(inputName));
			JObject additionalFields = val;
			SendRequest("OpenInputFiltersDialog", additionalFields);
		}

		public void OpenInputInteractDialog(string inputName)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("inputName", JToken.op_Implicit(inputName));
			JObject additionalFields = val;
			SendRequest("OpenInputInteractDialog", additionalFields);
		}

		public List<Monitor> GetMonitorList()
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Expected O, but got Unknown
			JObject obj = SendRequest("GetMonitorList");
			List<Monitor> list = new List<Monitor>();
			foreach (JToken item in (IEnumerable<JToken>)obj["monitors"])
			{
				list.Add(new Monitor((JObject)item));
			}
			return list;
		}

		public void OpenSourceProjector(string sourceName, string projectorGeometry, int monitorIndex = -1)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("sourceName", JToken.op_Implicit(sourceName));
			val.Add("projectorGeometry", JToken.op_Implicit(projectorGeometry));
			val.Add("monitorIndex", JToken.op_Implicit(monitorIndex));
			JObject additionalFields = val;
			SendRequest("OpenSourceProjector", additionalFields);
		}

		public void OpenVideoMixProjector(string videoMixType, string projectorGeometry, int monitorIndex = -1)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			JObject val = new JObject();
			val.Add("videoMixType", JToken.op_Implicit(videoMixType));
			val.Add("projectorGeometry", JToken.op_Implicit(projectorGeometry));
			val.Add("monitorIndex", JToken.op_Implicit(monitorIndex));
			JObject additionalFields = val;
			SendRequest("OpenVideoMixProjector", additionalFields);
		}
	}
	public class AuthFailureException : Exception
	{
	}
	public class ErrorResponseException : Exception
	{
		public int ErrorCode { get; set; }

		public ErrorResponseException(string message, int errorCode)
			: base(message)
		{
			ErrorCode = errorCode;
		}
	}
	public interface IOBSWebsocket
	{
		TimeSpan WSTimeout { get; set; }

		bool IsConnected { get; }

		event EventHandler<ProgramSceneChangedEventArgs> CurrentProgramSceneChanged;

		event EventHandler<SceneListChangedEventArgs> SceneListChanged;

		event EventHandler<SceneItemListReindexedEventArgs> SceneItemListReindexed;

		event EventHandler<SceneItemCreatedEventArgs> SceneItemCreated;

		event EventHandler<SceneItemRemovedEventArgs> SceneItemRemoved;

		event EventHandler<SceneItemEnableStateChangedEventArgs> SceneItemEnableStateChanged;

		event EventHandler<SceneItemLockStateChangedEventArgs> SceneItemLockStateChanged;

		event EventHandler<CurrentSceneCollectionChangedEventArgs> CurrentSceneCollectionChanged;

		event EventHandler<SceneCollectionListChangedEventArgs> SceneCollectionListChanged;

		event EventHandler<CurrentSceneTransitionChangedEventArgs> CurrentSceneTransitionChanged;

		event EventHandler<CurrentSceneTransitionDurationChangedEventArgs> CurrentSceneTransitionDurationChanged;

		event EventHandler<SceneTransitionStartedEventArgs> SceneTransitionStarted;

		event EventHandler<SceneTransitionEndedEventArgs> SceneTransitionEnded;

		event EventHandler<SceneTransitionVideoEndedEventArgs> SceneTransitionVideoEnded;

		event EventHandler<CurrentProfileChangedEventArgs> CurrentProfileChanged;

		event EventHandler<ProfileListChangedEventArgs> ProfileListChanged;

		event EventHandler<StreamStateChangedEventArgs> StreamStateChanged;

		event EventHandler<RecordStateChangedEventArgs> RecordStateChanged;

		event EventHandler<ReplayBufferStateChangedEventArgs> ReplayBufferStateChanged;

		event EventHandler<CurrentPreviewSceneChangedEventArgs> CurrentPreviewSceneChanged;

		event EventHandler<StudioModeStateChangedEventArgs> StudioModeStateChanged;

		event EventHandler ExitStarted;

		event EventHandler Connected;

		event EventHandler<ObsDisconnectionInfo> Disconnected;

		event EventHandler<SceneItemSelectedEventArgs> SceneItemSelected;

		event EventHandler<SceneItemTransformEventArgs> SceneItemTransformChanged;

		event EventHandler<InputAudioSyncOffsetChangedEventArgs> InputAudioSyncOffsetChanged;

		event EventHandler<SourceFilterCreatedEventArgs> SourceFilterCreated;

		event EventHandler<SourceFilterRemovedEventArgs> SourceFilterRemoved;

		event EventHandler<SourceFilterListReindexedEventArgs> SourceFilterListReindexed;

		event EventHandler<SourceFilterEnableStateChangedEventArgs> SourceFilterEnableStateChanged;

		event EventHandler<InputMuteStateChangedEventArgs> InputMuteStateChanged;

		event EventHandler<InputVolumeChangedEventArgs> InputVolumeChanged;

		event EventHandler<VendorEventArgs> VendorEvent;

		event EventHandler<MediaInputPlaybackEndedEventArgs> MediaInputPlaybackEnded;

		event EventHandler<MediaInputPlaybackStartedEventArgs> MediaInputPlaybackStarted;

		event EventHandler<MediaInputActionTriggeredEventArgs> MediaInputActionTriggered;

		event EventHandler<VirtualcamStateChangedEventArgs> VirtualcamStateChanged;

		event EventHandler<CurrentSceneCollectionChangingEventArgs> CurrentSceneCollectionChanging;

		event EventHandler<CurrentProfileChangingEventArgs> CurrentProfileChanging;

		event EventHandler<SourceFilterNameChangedEventArgs> SourceFilterNameChanged;

		event EventHandler<InputCreatedEventArgs> InputCreated;

		event EventHandler<InputRemovedEventArgs> InputRemoved;

		event EventHandler<InputNameChangedEventArgs> InputNameChanged;

		event EventHandler<InputActiveStateChangedEventArgs> InputActiveStateChanged;

		event EventHandler<InputShowStateChangedEventArgs> InputShowStateChanged;

		event EventHandler<InputAudioBalanceChangedEventArgs> InputAudioBalanceChanged;

		event EventHandler<InputAudioTracksChangedEventArgs> InputAudioTracksChanged;

		event EventHandler<InputAudioMonitorTypeChangedEventArgs> InputAudioMonitorTypeChanged;

		event EventHandler<InputVolumeMetersEventArgs> InputVolumeMeters;

		event EventHandler<ReplayBufferSavedEventArgs> ReplayBufferSaved;

		event EventHandler<SceneCreatedEventArgs> SceneCreated;

		event EventHandler<SceneRemovedEventArgs> SceneRemoved;

		event EventHandler<SceneNameChangedEventArgs> SceneNameChanged;

		ObsVideoSettings GetVideoSettings();

		string SaveSourceScreenshot(string sourceName, string imageFormat, string imageFilePath, int imageWidth = -1, int imageHeight = -1, int imageCompressionQuality = -1);

		string SaveSourceScreenshot(string sourceName, string imageFormat, string imageFilePath);

		void TriggerHotkeyByName(string hotkeyName);

		void TriggerHotkeyByKeySequence(OBSHotkey keyId, KeyModifier keyModifier = KeyModifier.None);

		string GetCurrentProgramScene();

		void SetCurrentProgramScene(string sceneName);

		ObsStats GetStats();

		List<SceneBasicInfo> ListScenes();

		GetSceneListInfo GetSceneList();

		TransitionOverrideInfo GetSceneSceneTransitionOverride(string sceneName);

		void SetSceneSceneTransitionOverride(string sceneName, string transitionName, int transitionDuration = -1);

		void SetTBarPosition(double position, bool release = true);

		void SetSourceFilterSettings(string sourceName, string filterName, JObject filterSettings, bool overlay = false);

		void SetSourceFilterSettings(string sourceName, string filterName, FilterSettings filterSettings, bool overlay = false);

		void SetSourceFilterEnabled(string sourceName, string filterName, bool filterEnabled);

		List<FilterSettings> GetSourceFilterList(string sourceName);

		FilterSettings GetSourceFilter(string sourceName, string filterName);

		bool RemoveSourceFilter(string sourceName, string filterName);

		void CreateSourceFilter(string sourceName, string filterName, string filterKind, JObject filterSettings);

		void CreateSourceFilter(string sourceName, string filterName, string filterKind, FilterSettings filterSettings);

		bool ToggleStream();

		void ToggleRecord();

		OutputStatus GetStreamStatus();

		TransitionSettings GetCurrentSceneTransition();

		void SetCurrentSceneTransition(string transitionName);

		void SetCurrentSceneTransitionDuration(int transitionDuration);

		void SetCurrentSceneTransitionSettings(JObject transitionSettings, bool overlay);

		void SetInputVolume(string inputName, float inputVolume, bool inputVolumeDb = false);

		VolumeInfo GetInputVolume(string inputName);

		bool GetInputMute(string inputName);

		void SetInputMute(string inputName, bool inputMuted);

		void ToggleInputMute(string inputName);

		void SetSceneItemTransform(string sceneName, int sceneItemId, JObject sceneItemTransform);

		void SetSceneItemTransform(string sceneName, int sceneItemId, SceneItemTransformInfo sceneItemTransform);

		void SetCurrentSceneCollection(string sceneCollectionName);

		string GetCurrentSceneCollection();

		List<string> GetSceneCollectionList();

		void SetCurrentProfile(string profileName);

		GetProfileListInfo GetProfileList();

		void StartStream();

		void StopStream();

		void StartRecord();

		string StopRecord();

		void PauseRecord();

		void ResumeRecord();

		string GetRecordDirectory();

		RecordingStatus GetRecordStatus();

		bool GetReplayBufferStatus();

		GetTransitionListInfo GetSceneTransitionList();

		bool GetStudioModeEnabled();

		void SetStudioModeEnabled(bool studioModeEnabled);

		string GetCurrentPreviewScene();

		void SetCurrentPreviewScene(string sceneName);

		void SetCurrentPreviewScene(ObsScene previewScene);

		void TriggerStudioModeTransition();

		void ToggleReplayBuffer();

		void StartReplayBuffer();

		void StopReplayBuffer();

		void SaveReplayBuffer();

		void SetInputAudioSyncOffset(string inputName, int inputAudioSyncOffset);

		int GetInputAudioSyncOffset(string inputName);

		void RemoveSceneItem(string sceneName, int sceneItemId);

		void SendStreamCaption(string captionText);

		void DuplicateSceneItem(string sceneName, int sceneItemId, string destinationSceneName = null);

		Dictionary<string, string> GetSpecialInputs();

		void SetStreamServiceSettings(StreamingService service);

		StreamingService GetStreamServiceSettings();

		string GetInputAudioMonitorType(string inputName);

		void SetInputAudioMonitorType(string inputName, string monitorType);

		void BroadcastCustomEvent(JObject eventData);

		void SetMediaInputCursor(string inputName, int mediaCursor);

		void OffsetMediaInputCursor(string inputName, int mediaCursorOffset);

		int CreateInput(string sceneName, string inputName, string inputKind, JObject inputSettings, bool? sceneItemEnabled);

		JObject GetInputDefaultSettings(string inputKind);

		List<SceneItemDetails> GetSceneItemList(string sceneName);

		int CreateSceneItem(string sceneName, string sourceName, bool sceneItemEnabled = true);

		void CreateScene(string sceneName);

		SourceTracks GetInputAudioTracks(string inputName);

		void SetInputAudioTracks(string inputName, JObject inputAudioTracks);

		void SetInputAudioTracks(string inputName, SourceTracks inputAudioTracks);

		SourceActiveInfo GetSourceActive(string sourceName);

		VirtualCamStatus GetVirtualCamStatus();

		void StartVirtualCam();

		void StopVirtualCam();

		VirtualCamStatus ToggleVirtualCam();

		JObject GetPersistentData(string realm, string slotName);

		void SetPersistentData(string realm, string slotName, JObject slotValue);

		void CreateSceneCollection(string sceneCollectionName);

		void CreateProfile(string profileName);

		void RemoveProfile(string profileName);

		JObject GetProfileParameter(string parameterCategory, string parameterName);

		void SetProfileParameter(string parameterCategory, string parameterName, string parameterValue);

		void SetVideoSettings(ObsVideoSettings obsVideoSettings);

		JObject GetSourceFilterDefaultSettings(string filterKind);

		void SetSourceFilterName(string sourceName, string filterName, string newFilterName);

		void SetSourceFilterIndex(string sourceName, string filterName, int filterIndex);

		ObsVersion GetVersion();

		JObject CallVendorRequest(string vendorName, string requestType, JObject requestData = null);

		List<string> GetHotkeyList();

		void Sleep(int sleepMillis, int sleepFrames);

		List<InputBasicInfo> GetInputList(string inputKind = null);

		List<string> GetInputKindList(bool unversioned = false);

		void RemoveInput(string inputName);

		void SetInputName(string inputName, string newInputName);

		InputSettings GetInputSettings(string inputName);

		void SetInputSettings(InputSettings inputSettings, bool overlay = true);

		void SetInputSettings(string inputName, JObject inputSettings, bool overlay = true);

		double GetInputAudioBalance(string inputName);

		void SetInputAudioBalance(string inputName, double inputAudioBalance);

		List<JObject> GetInputPropertiesListPropertyItems(string inputName, string propertyName);

		void PressInputPropertiesButton(string inputName, string propertyName);

		MediaInputStatus GetMediaInputStatus(string inputName);

		void TriggerMediaInputAction(string inputName, string mediaAction);

		string GetLastReplayBufferReplay();

		void ToggleRecordPause();

		List<JObject> GetGroupSceneItemList(string sceneName);

		int GetSceneItemId(string sceneName, string sourceName, int searchOffset);

		SceneItemTransformInfo GetSceneItemTransform(string sceneName, int sceneItemId);

		JObject GetSceneItemTransformRaw(string sceneName, int sceneItemId);

		bool GetSceneItemEnabled(string sceneName, int sceneItemId);

		void SetSceneItemEnabled(string sceneName, int sceneItemId, bool sceneItemEnabled);

		bool GetSceneItemLocked(string sceneName, int sceneItemId);

		void SetSceneItemLocked(string sceneName, int sceneItemId, bool sceneItemLocked);

		int GetSceneItemIndex(string sceneName, int sceneItemId);

		void SetSceneItemIndex(string sceneName, int sceneItemId, int sceneItemIndex);

		string GetSceneItemBlendMode(string sceneName, int sceneItemId);

		void SetSceneItemBlendMode(string sceneName, int sceneItemId, string sceneItemBlendMode);

		List<string> GetGroupList();

		void RemoveScene(string sceneName);

		void SetSceneName(string sceneName, string newSceneName);

		string GetSourceScreenshot(string sourceName, string imageFormat, int imageWidth = -1, int imageHeight = -1, int imageCompressionQuality = -1);

		List<string> GetTransitionKindList();

		double GetCurrentSceneTransitionCursor();

		void OpenInputPropertiesDialog(string inputName);

		void OpenInputFiltersDialog(string inputName);

		void OpenInputInteractDialog(string inputName);

		List<Monitor> GetMonitorList();

		[Obsolete("Please use ConnectAsync, this function will be removed in the next version")]
		void Connect(string url, string password);

		void ConnectAsync(string url, string password);

		void Disconnect();

		JObject SendRequest(string requestType, JObject additionalFields = null);

		OBSAuthInfo GetAuthInfo();
	}
}
namespace OBSWebsocketDotNet.Types
{
	public class FilterReorderItem
	{
		[JsonProper