// This file is generated. Do not modify by hand.
// XML documentation file not found. To check if public methods have XML comments,
// make sure the XML doc file is present and located next to the scraped dll
public class AccumulationSettings
{
    public bool CaptureAccumulation { get; set; }
    public int Samples { get; set; }
    public float ShutterBeginsClosing { get; set; }
    public float ShutterFullyOpen { get; set; }
    public float ShutterInterval { get; set; }
    public UnityEngine.AnimationCurve ShutterProfileCurve { get; set; }
    public AccumulationSettings.ShutterProfileType ShutterType { get; set; }
    public bool UseSubPixelJitter { get; set; }
    public AccumulationSettings() {}
    public enum ShutterProfileType
    {
        Curve = 1,
        Range = 0,
    }
}

public interface IAccumulation
{
    public AccumulationSettings GetAccumulationSettings();
}

namespace UnityEditor.Recorder
{
    [RecorderSettings(typeof(AnimationRecorder), @"Animation Clip", @"animation_recorder")] public class AnimationRecorderSettings : RecorderSettings
    {
        public Input.AnimationInputSettings AnimationInputSettings { get; set; }
        protected override string Extension { get; }
        public override System.Collections.Generic.IEnumerable<RecorderInputSettings> InputsSettings { get; }
        public override bool IsPlatformSupported { get; }
        public AnimationRecorderSettings() {}
        protected override void GetErrors(System.Collections.Generic.List<string> errors);
        public override void OnAfterDuplicate();
    }

    [RecorderSettings(typeof(AOVRecorder), @"AOV Image Sequence", @"aovimagesequence_16")] public class AOVRecorderSettings : RecorderSettings
    {
        [System.Obsolete(@"Use Get/SetAOVSelection to choose the AOVs")] public AOVType AOVSelection { get; set; }
        public bool CaptureHDR { get; }
        public CompressionUtility.EXRCompressionType EXRCompression { get; set; }
        public int EXRCompressionLevel { get; set; }
        protected override string Extension { get; }
        public Input.ImageInputSettings imageInputSettings { get; set; }
        public override System.Collections.Generic.IEnumerable<RecorderInputSettings> InputsSettings { get; }
        public bool IsMultiPartEXR { get; set; }
        protected override int LatestVersion { get; }
        public ImageRecorderSettings.ColorSpaceType OutputColorSpace { get; set; }
        public ImageRecorderSettings.ImageRecorderOutputFormat OutputFormat { get; set; }
        protected override int Version { get; set; }
        public AOVRecorderSettings() {}
        public AOVType[] GetAOVSelection();
        protected override void GetErrors(System.Collections.Generic.List<string> errors);
        protected override void OnUpgradeFromVersion();
        public void SetAOVSelection(params AOVType[] value);
    }

    public enum AOVType
    {
        Albedo = 1,
        Alpha = 7,
        AmbientOcclusion = 4,
        Beauty = 0,
        Depth = 15,
        DirectDiffuse = 8,
        DirectSpecular = 9,
        Emissive = 13,
        IndirectDiffuse = 10,
        Metal = 5,
        MotionVectors = 14,
        Normal = 2,
        Reflection = 11,
        Refraction = 12,
        Smoothness = 3,
        Specular = 6,
    }

    [RecorderSettings(typeof(AudioRecorder), @"Audio")] public class AudioRecorderSettings : RecorderSettings
    {
        protected override string Extension { get; }
        public override System.Collections.Generic.IEnumerable<RecorderInputSettings> InputsSettings { get; }
        public AudioRecorderSettings() {}
        protected override void GetErrors(System.Collections.Generic.List<string> errors);
    }

    public abstract class BaseRenderTextureInput : RecorderInput
    {
        public int OutputHeight { get; protected set; }
        protected UnityEngine.RenderTexture OutputRenderTexture { get; set; }
        public int OutputWidth { get; protected set; }
        [System.Obsolete] protected UnityEngine.Texture2D ReadbackTexture { get; set; }
        protected BaseRenderTextureInput() {}
        protected override void Dispose(bool disposing);
        protected void ReleaseBuffer();
    }

    public abstract class BaseTextureRecorder<T> : UnityEditor.Recorder.GenericRecorder<T> where T : RecorderSettings
    {
        protected bool UseAsyncGPUReadback;
        protected abstract UnityEngine.TextureFormat ReadbackTextureFormat { get; }
        protected BaseTextureRecorder() {}
        protected override bool BeginRecording(RecordingSession session);
        protected virtual void DisposeEncoder();
        protected override void EndRecording(RecordingSession session);
        protected override void PrepareNewFrame(RecordingSession ctx);
        protected override void RecordFrame(RecordingSession session);
        protected virtual void WriteFrame(UnityEngine.Rendering.AsyncGPUReadbackRequest r);
        protected virtual void WriteFrame(UnityEngine.Texture2D t);
    }

    public static class BindingManager
    {
        public static void Duplicate(string id, string newId);
        public static UnityEngine.Object Get(string id);
        public static void Set(string id, UnityEngine.Object obj);
    }

    public static class CompressionUtility
    {
        public enum EXRCompressionType
        {
            B44 = 5,
            B44a = 6,
            DWAA = 7,
            DWAB = 8,
            None = 0,
            PIZ = 3,
            RLE = 1,
            Zip = 2,
            Zips = 4,
        }
    }

    public static class DefaultWildcard
    {
        public static readonly string Date;
        public static readonly string Extension;
        public static readonly string Frame;
        public static readonly string Product;
        public static readonly string Project;
        public static readonly string Recorder;
        public static readonly string Resolution;
        public static readonly string Scene;
        public static readonly string Take;
        public static readonly string Time;
        public static string GeneratePattern(string tag);
    }

    public class FileNameGenerator
    {
        public string FileName { get; set; }
        public bool ForceAssetsFolder { get; set; }
        public string Leaf { get; set; }
        public OutputPath.Root Root { get; set; }
        public void AddWildcard(string tag, System.Func<RecordingSession, string> resolver);
        public string BuildAbsolutePath(RecordingSession session);
        public void CreateDirectory(RecordingSession session);
        public static string SanitizePath(string fullPath);
    }

    public enum FrameRatePlayback
    {
        Constant = 0,
        Variable = 1,
    }

    public abstract class GenericRecorder<T> : Recorder where T : RecorderSettings
    {
        public T Settings { get; set; }
        protected GenericRecorder() {}
    }

    [RecorderSettings(typeof(GIFRecorder), @"GIF Animation", @"imagesequence_16")] [System.Obsolete(@"The GIFRecorder is deprecated")] public class GIFRecorderSettings : FrameCapturer.BaseFCRecorderSettings
    {
        protected override string Extension { get; }
        [System.Obsolete(@"The GIFRecorder is deprecated")] public GIFRecorderSettings() {}
    }

    public class ImageInputSelector : InputSettingsSelector
    {
        [UnityEngine.SerializeField] public Input.Camera360InputSettings camera360InputSettings;
        [UnityEngine.SerializeField] public Input.CameraInputSettings cameraInputSettings;
        [UnityEngine.SerializeField] public Input.GameViewInputSettings gameViewInputSettings;
        [UnityEngine.SerializeField] public Input.RenderTextureInputSettings renderTextureInputSettings;
        [UnityEngine.SerializeField] public Input.RenderTextureSamplerSettings renderTextureSamplerSettings;
        public Input.ImageInputSettings ImageInputSettings { get; set; }
        public ImageInputSelector() {}
    }

    [RecorderSettings(typeof(ImageRecorder), @"Image Sequence", @"imagesequence_16")] public class ImageRecorderSettings : RecorderSettings, IAccumulation
    {
        public AccumulationSettings AccumulationSettings { get; set; }
        public bool CaptureAlpha { get; set; }
        public bool CaptureHDR { get; }
        public CompressionUtility.EXRCompressionType EXRCompression { get; set; }
        protected override string Extension { get; }
        public Input.ImageInputSettings imageInputSettings { get; set; }
        public override System.Collections.Generic.IEnumerable<RecorderInputSettings> InputsSettings { get; }
        public int JpegQuality { get; set; }
        public ImageRecorderSettings.ColorSpaceType OutputColorSpace { get; set; }
        public ImageRecorderSettings.ImageRecorderOutputFormat OutputFormat { get; set; }
        public ImageRecorderSettings() {}
        public AccumulationSettings GetAccumulationSettings();
        protected override void GetErrors(System.Collections.Generic.List<string> errors);
        protected override void GetWarnings(System.Collections.Generic.List<string> warnings);
        protected override bool HasErrors();
        public override bool IsAccumulationSupported();
        public enum ColorSpaceType
        {
            sRGB_sRGB = 0,
            Unclamped_linear_sRGB = 1,
        }
        [System.Obsolete(@"Use CompressionUtility.EXRCompressionType instead. (UnityUpgradable) -> UnityEditor.Recorder.CompressionUtility/EXRCompressionType")] public enum EXRCompressionType
        {
            None = 0,
            PIZ = 3,
            RLE = 1,
            Zip = 2,
        }
        public enum ImageRecorderOutputFormat
        {
            EXR = 2,
            JPEG = 1,
            PNG = 0,
        }
    }

    [System.Flags] public enum ImageSource
    {
        ActiveCamera = 1,
        MainCamera = 2,
        TaggedCamera = 4,
    }

    public abstract class InputSettingsSelector
    {
        public RecorderInputSettings Selected { get; protected set; }
        protected InputSettingsSelector() {}
    }

    [RecorderSettings(typeof(MovieRecorder), @"Movie", @"movie_16")] public class MovieRecorderSettings : RecorderSettings, IAccumulation
    {
        public AccumulationSettings AccumulationSettings { get; set; }
        public Input.AudioInputSettings AudioInputSettings { get; }
        public bool CaptureAlpha { get; set; }
        public bool CaptureAudio { get; set; }
        public Encoder.IEncoderSettings EncoderSettings { get; set; }
        [System.Obsolete(@"Please use the EncoderSettings API to set/get the bitrate/encoding quality of each Encoder.")] public MovieRecorderSettings.VideoEncodingQuality EncodingQuality { get; set; }
        protected override string Extension { get; }
        public Input.ImageInputSettings ImageInputSettings { get; set; }
        public override System.Collections.Generic.IEnumerable<RecorderInputSettings> InputsSettings { get; }
        protected override int LatestVersion { get; }
        [System.Obsolete(@"Please use the EncoderSettings API to set/get the format/codec of each Encoder.")] public MovieRecorderSettings.VideoRecorderOutputFormat OutputFormat { get; set; }
        protected override int Version { get; set; }
        [System.Obsolete(@"Please use the EncoderSettings API to set/get the bitrate/encoding quality of each Encoder.")] public VideoBitrateMode VideoBitRateMode { get; set; }
        public MovieRecorderSettings() {}
        public AccumulationSettings GetAccumulationSettings();
        protected override void GetErrors(System.Collections.Generic.List<string> errors);
        protected override void GetWarnings(System.Collections.Generic.List<string> warnings);
        protected override bool HasErrors();
        public override bool IsAccumulationSupported();
        protected override void OnUpgradeFromVersion();
        [System.Obsolete(@"Please use the EncoderSettings API to access the encoding quality of each Encoder.")] public enum VideoEncodingQuality
        {
            High = 2,
            Low = 0,
            Medium = 1,
        }
        [System.Obsolete(@"Please use the EncoderSettings API to access the format/codec of each Encoder.")] public enum VideoRecorderOutputFormat
        {
            [UnityEngine.InspectorName(@"ProRes QuickTime")] MOV = 2,
            [UnityEngine.InspectorName(@"H.264 MP4")] MP4 = 0,
            [UnityEngine.InspectorName(@"VP8 WebM")] WebM = 1,
        }
    }

    public class OutputPath
    {
        public OutputPath() {}
        public enum Root
        {
            Absolute = 5,
            AssetsFolder = 1,
            PersistentData = 3,
            Project = 0,
            StreamingAssets = 2,
            TemporaryCache = 4,
        }
    }

    public abstract class Recorder : UnityEngine.ScriptableObject
    {
        protected System.Collections.Generic.List<RecorderInput> m_Inputs;
        protected int RecordedFramesCount { get; }
        public bool Recording { get; protected set; }
        protected Recorder() {}
        protected virtual bool BeginRecording(RecordingSession session);
        protected void ConsoleLogMessage(string message, UnityEngine.LogType logType);
        protected virtual void EndRecording(RecordingSession session);
        protected virtual void PrepareNewFrame(RecordingSession ctx);
        protected abstract void RecordFrame(RecordingSession ctx);
        protected virtual void Reset();
        protected virtual void SessionCreated(RecordingSession session);
        protected virtual bool SkipFrame(RecordingSession ctx);
        protected virtual bool SkipSubFrame(RecordingSession ctx);
    }

    public class RecorderController
    {
        public RecorderControllerSettings Settings { get; }
        public RecorderController(RecorderControllerSettings settings) {}
        public bool IsRecording();
        public void PrepareRecording();
        public bool StartRecording();
        public void StopRecording();
    }

    public class RecorderControllerSettings : UnityEngine.ScriptableObject
    {
        public bool CapFrameRate { get; set; }
        public bool ExitPlayMode { get; set; }
        public float FrameRate { get; set; }
        public FrameRatePlayback FrameRatePlayback { get; set; }
        public System.Collections.Generic.IEnumerable<RecorderSettings> RecorderSettings { get; }
        public RecorderControllerSettings() {}
        public void AddRecorderSettings(RecorderSettings recorder);
        public static RecorderControllerSettings GetGlobalSettings();
        public static RecorderControllerSettings LoadOrCreate(string path);
        public void RemoveRecorder(RecorderSettings recorder);
        public void Save();
        public void SetRecordModeToFrameInterval(int startFrame, int endFrame);
        public void SetRecordModeToManual();
        public void SetRecordModeToSingleFrame(int frameNumber);
        public void SetRecordModeToTimeInterval(float startTime, float endTime);
    }

    public class RecorderControllerSettingsPreset : UnityEngine.ScriptableObject
    {
        public RecorderControllerSettingsPreset() {}
        public void ApplyTo(RecorderControllerSettings prefs);
        public static void SaveAtPath(RecorderControllerSettings model, string path);
    }

    public abstract class RecorderEditor : Editor
    {
        protected RecorderEditor() {}
        protected virtual void AccumulationGUI();
        protected static void DrawSeparator();
        protected virtual void ExtraOptionsGUI();
        protected virtual void FileTypeAndFormatGUI();
        protected virtual void ImageRenderOptionsGUI();
        protected virtual void NameAndPathGUI();
        protected virtual void OnEnable();
        protected virtual void OnEncodingGui();
        public override void OnInspectorGUI();
        protected virtual void OnValidateSettingsGUI();
    }

    public class RecorderInput : System.IDisposable
    {
        public RecorderInputSettings settings { get; set; }
        public RecorderInput() {}
        protected virtual void BeginRecording(RecordingSession session);
        public void Dispose();
        protected virtual void Dispose(bool disposing);
        protected virtual void EndRecording(RecordingSession session);
        protected override void Finalize();
        protected virtual void FrameDone(RecordingSession session);
        protected virtual void NewFrameReady(RecordingSession session);
        protected virtual void NewFrameStarting(RecordingSession session);
        protected virtual void SessionCreated(RecordingSession session);
    }

    public abstract class RecorderInputSettings
    {
        protected abstract System.Type InputType { get; }
        protected RecorderInputSettings() {}
        protected virtual void CheckForErrors(System.Collections.Generic.List<string> errors);
        protected virtual void CheckForWarnings(System.Collections.Generic.List<string> warnings);
        [System.Obsolete(@"Please use methods CheckForErrors() and CheckForWarnings()")] protected virtual bool ValidityCheck(System.Collections.Generic.List<string> errors);
    }

    public static class RecorderOptions
    {
        public static bool ShowRecorderGameObject { get; set; }
        public static bool VerboseMode { get; set; }
    }

    public abstract class RecorderSettings : UnityEngine.ScriptableObject, UnityEngine.ISerializationCallbackReceiver
    {
        public bool CapFrameRate { get; set; }
        public bool Enabled { get; set; }
        public int EndFrame { get; set; }
        public float EndTime { get; set; }
        protected abstract string Extension { get; }
        public FileNameGenerator FileNameGenerator { get; }
        public float FrameRate { get; set; }
        public FrameRatePlayback FrameRatePlayback { get; set; }
        public abstract System.Collections.Generic.IEnumerable<RecorderInputSettings> InputsSettings { get; }
        public virtual bool IsPlatformSupported { get; }
        protected virtual int LatestVersion { get; }
        public string OutputFile { get; set; }
        public RecordMode RecordMode { get; set; }
        public int StartFrame { get; set; }
        public float StartTime { get; set; }
        public int Take { get; set; }
        protected virtual int Version { get; set; }
        protected RecorderSettings() {}
        protected virtual void GetErrors(System.Collections.Generic.List<string> errors);
        protected virtual void GetWarnings(System.Collections.Generic.List<string> warnings);
        protected virtual bool HasErrors();
        public virtual bool IsAccumulationSupported();
        protected virtual void OnAfterDeserialize();
        public virtual void OnAfterDuplicate();
        protected virtual void OnBeforeSerialize();
        protected virtual void OnUpgradeFromVersion();
        [System.Obsolete(@"Please use methods GetErrors() and GetWarnings()")] protected virtual bool ValidityCheck(System.Collections.Generic.List<string> errors);
    }

    [System.AttributeUsage(System.AttributeTargets.Class, Inherited = false)] public class RecorderSettingsAttribute : System.Attribute
    {
        public RecorderSettingsAttribute(System.Type recorderType, string displayName) {}
        public RecorderSettingsAttribute(System.Type recorderType, string displayName, string iconName) {}
    }

    public class RecorderWindow : EditorWindow
    {
        public const string MenuRoot = @"Window/General/Recorder/";
        public const int MenuRootIndex = 1000;
        public RecorderWindow() {}
        public void ApplyPreset(RecorderControllerSettingsPreset preset);
        public bool IsRecording();
        public void SetRecorderControllerSettings(RecorderControllerSettings settings);
        public void StartRecording();
        public void StopRecording();
    }

    public class RecordingSession : System.IDisposable
    {
        public Recorder recorder;
        public int frameIndex { get; }
        public float recorderTime { get; }
        public RecorderSettings settings { get; }
        public RecordingSession() {}
        public void Dispose();
    }

    public enum RecordMode
    {
        FrameInterval = 2,
        Manual = 0,
        SingleFrame = 1,
        TimeInterval = 3,
    }

    public static class UnityHelpers
    {
        public static void Destroy(UnityEngine.Object obj, bool allowDestroyingAssets = false);
    }

    public class WAVEncoder : System.IDisposable
    {
        public WAVEncoder(string filename) {}
        public void AddSamples(Unity.Collections.NativeArray<float> data);
        public void Dispose();
        public void Stop();
    }
}

namespace UnityEditor.Recorder.Encoder
{
    [EncoderSettings(typeof(CoreEncoder))] [System.ComponentModel.DisplayName(@"Unity Media Encoder")] public sealed class CoreEncoderSettings : IEncoderSettings, System.IEquatable<CoreEncoderSettings>
    {
        public CoreEncoderSettings.OutputCodec Codec { get; set; }
        public CoreEncoderSettings.H264EncodingProfile EncodingProfile { get; set; }
        public CoreEncoderSettings.VideoEncodingQuality EncodingQuality { get; set; }
        public System.UInt32 GopSize { get; set; }
        public System.UInt32 KeyframeDistance { get; set; }
        public System.UInt32 NumConsecutiveBFrames { get; set; }
        public float TargetBitRate { get; set; }
        public CoreEncoderSettings() {}
        public override bool Equals(object obj);
        public override int GetHashCode();
        public bool SupportsCurrentPlatform();
        public enum H264EncodingProfile
        {
            [UnityEngine.InspectorName(@"H.264 Baseline")] Baseline = 0,
            [UnityEngine.InspectorName(@"H.264 High")] High = 2,
            [UnityEngine.InspectorName(@"H.264 Main")] Main = 1,
        }
        public enum OutputCodec
        {
            [UnityEngine.InspectorName(@"H.264 MP4")] MP4 = 0,
            [UnityEngine.InspectorName(@"VP8 WebM")] WEBM = 1,
        }
        public enum VideoEncodingQuality
        {
            Custom = 3,
            High = 2,
            Low = 0,
            Medium = 1,
        }
    }

    public enum EncoderCoordinateConvention
    {
        OriginIsBottomLeft = 1,
        OriginIsTopLeft = 0,
    }

    [System.AttributeUsage(System.AttributeTargets.Class, Inherited = false)] public class EncoderSettingsAttribute : System.Attribute
    {
        public EncoderSettingsAttribute(System.Type encoderType) {}
    }

    [EncoderSettings(typeof(GifEncoder))] [System.ComponentModel.DisplayName(@"GIF Encoder")] public sealed class GifEncoderSettings : IEncoderSettings, System.IEquatable<GifEncoderSettings>
    {
        public bool Loop { get; set; }
        public System.UInt32 Quality { get; set; }
        public GifEncoderSettings() {}
        public override bool Equals(object obj);
        public override int GetHashCode();
        public bool SupportsCurrentPlatform();
    }

    public interface IEncoder
    {
        public IEncoder.VideoInputPath GetVideoInputPath { get; }
        public void AddAudioFrame(Unity.Collections.NativeArray<float> bytes);
        public void AddVideoFrame(Unity.Collections.NativeArray<byte> bytes, UnityEditor.Media.MediaTime time);
        public void AddVideoFrame(UnityEngine.RenderTexture frame, UnityEditor.Media.MediaTime time);
        public void CloseStream();
        public void OpenStream(IEncoderSettings settings, RecordingContext ctx);
        public enum VideoInputPath
        {
            CPUBuffer = 1,
            GPUBuffer = 0,
        }
    }

    public interface IEncoderSettings
    {
        public bool CanCaptureAlpha { get; }
        public bool CanCaptureAudio { get; }
        public EncoderCoordinateConvention CoordinateConvention { get; }
        public string Extension { get; }
        public UnityEngine.TextureFormat GetTextureFormat(bool inputContainsAlpha);
        [System.Obsolete(@"RequiresEvenResolution() is no longer used.")] public bool RequiresEvenResolution();
        public bool SupportsCurrentPlatform();
        public void ValidateRecording(RecordingContext ctx, System.Collections.Generic.List<string> errors, System.Collections.Generic.List<string> warnings);
    }

    [EncoderSettings(typeof(ProResEncoder))] [System.ComponentModel.DisplayName(@"ProRes Encoder")] public sealed class ProResEncoderSettings : IEncoderSettings, System.IEquatable<ProResEncoderSettings>
    {
        public ProResEncoderSettings.OutputFormat Format { get; set; }
        public ProResEncoderSettings() {}
        public override bool Equals(object obj);
        public override int GetHashCode();
        public bool SupportsCurrentPlatform();
        public enum OutputFormat
        {
            [UnityEngine.InspectorName(@"Apple ProRes 422 (apcn)")] ProRes422 = 3,
            [UnityEngine.InspectorName(@"Apple ProRes 422 HQ (apch)")] ProRes422HQ = 2,
            [UnityEngine.InspectorName(@"Apple ProRes 422 LT (apcs)")] ProRes422LT = 4,
            [UnityEngine.InspectorName(@"Apple ProRes 422 Proxy (apco)")] ProRes422Proxy = 5,
            [UnityEngine.InspectorName(@"Apple ProRes 4444 (ap4h)")] ProRes4444 = 1,
            [UnityEngine.InspectorName(@"Apple ProRes 4444 XQ (ap4x)")] ProRes4444XQ = 0,
        }
        public enum ProResColorDefinition
        {
            HD_Rec709 = 2,
        }
    }

    public struct RecordingContext
    {
        public bool doCaptureAlpha;
        public bool doCaptureAudio;
        public UnityEditor.Media.MediaRational fps;
        public FrameRatePlayback frameRateMode;
        public int height;
        public string path;
        public int width;
    }
}

namespace UnityEditor.Recorder.FrameCapturer
{
    [System.Obsolete(@"The legacy recorders are deprecated")] public abstract class BaseFCRecorderSettings : RecorderSettings
    {
        public UnityEditor.Recorder.Input.ImageInputSettings imageInputSettings { get; set; }
        public override System.Collections.Generic.IEnumerable<RecorderInputSettings> InputsSettings { get; }
        protected BaseFCRecorderSettings() {}
    }
}

namespace UnityEditor.Recorder.Input
{
    public class AnimationInput : RecorderInput
    {
        public UnityEditor.Animations.GameObjectRecorder GameObjectRecorder { get; }
        public AnimationInput() {}
        protected override void BeginRecording(RecordingSession session);
        protected override void NewFrameReady(RecordingSession session);
    }

    [System.ComponentModel.DisplayName(@"Animation")] public class AnimationInputSettings : RecorderInputSettings
    {
        public bool ClampedTangents { get; set; }
        public UnityEngine.GameObject gameObject { get; set; }
        protected override System.Type InputType { get; }
        public bool Recursive { get; set; }
        public AnimationInputSettings.CurveSimplificationOptions SimplyCurves { get; set; }
        public AnimationInputSettings() {}
        public void AddComponentToRecord(System.Type componentType);
        protected override void CheckForErrors(System.Collections.Generic.List<string> errors);
        public void ClearExposedReference();
        public void DuplicateExposedReference();
        public enum CurveSimplificationOptions
        {
            Disabled = 2,
            Lossless = 1,
            Lossy = 0,
        }
    }

    public class AOVCameraInputSettings : CameraInputSettings
    {
        protected override System.Type InputType { get; }
        public AOVCameraInputSettings() {}
    }

    public class AudioInput : RecorderInput
    {
        public AudioInputSettings AudioSettings { get; }
        public System.UInt16 ChannelCount { get; }
        public int SampleRate { get; }
        public AudioInput() {}
        protected override void BeginRecording(RecordingSession session);
        protected override void EndRecording(RecordingSession session);
        protected override void FrameDone(RecordingSession session);
        public void GetBuffer(ref Unity.Collections.NativeArray<float> userArray, out int writtenSize);
        public int GetBufferSize();
        protected override void NewFrameReady(RecordingSession session);
    }

    [System.ComponentModel.DisplayName(@"Audio")] public class AudioInputSettings : RecorderInputSettings
    {
        protected override System.Type InputType { get; }
        public bool PreserveAudio { get; set; }
        public AudioInputSettings() {}
    }

    [System.ComponentModel.DisplayName(@"360 View")] public class Camera360InputSettings : ImageInputSettings
    {
        public string CameraTag { get; set; }
        public bool FlipFinalOutput { get; set; }
        protected override System.Type InputType { get; }
        public int MapSize { get; set; }
        public override int OutputHeight { get; set; }
        public override int OutputWidth { get; set; }
        public bool RenderStereo { get; set; }
        public ImageSource Source { get; set; }
        public float StereoSeparation { get; set; }
        public Camera360InputSettings() {}
        protected override void CheckForErrors(System.Collections.Generic.List<string> errors);
    }

    public class CameraInput : BaseRenderTextureInput
    {
        protected UnityEngine.Camera TargetCamera { get; set; }
        public CameraInput() {}
        protected override void BeginRecording(RecordingSession session);
        protected override void Dispose(bool disposing);
        protected override void EndRecording(RecordingSession session);
        protected override void NewFrameReady(RecordingSession session);
        protected override void NewFrameStarting(RecordingSession session);
    }

    [System.ComponentModel.DisplayName(@"Targeted Camera")] public class CameraInputSettings : StandardImageInputSettings
    {
        public string CameraTag { get; set; }
        public bool CaptureUI { get; set; }
        public bool FlipFinalOutput { get; set; }
        protected override System.Type InputType { get; }
        public ImageSource Source { get; set; }
        public CameraInputSettings() {}
        protected override void CheckForErrors(System.Collections.Generic.List<string> errors);
    }

    [System.ComponentModel.DisplayName(@"Game View")] public class GameViewInputSettings : StandardImageInputSettings
    {
        public bool FlipFinalOutput { get; set; }
        protected override System.Type InputType { get; }
        public override bool SupportsTransparent { get; }
        public GameViewInputSettings() {}
    }

    public abstract class ImageInputSettings : RecorderInputSettings
    {
        public abstract int OutputHeight { get; set; }
        public abstract int OutputWidth { get; set; }
        public bool RecordTransparency { get; set; }
        public virtual bool SupportsTransparent { get; }
        protected ImageInputSettings() {}
    }

    [System.ComponentModel.DisplayName(@"Render Texture Asset")] public class RenderTextureInputSettings : ImageInputSettings
    {
        public bool FlipFinalOutput { get; set; }
        protected override System.Type InputType { get; }
        public override int OutputHeight { get; set; }
        public override int OutputWidth { get; set; }
        public UnityEngine.RenderTexture RenderTexture { get; set; }
        public RenderTextureInputSettings() {}
        protected override void CheckForErrors(System.Collections.Generic.List<string> errors);
    }

    [System.ComponentModel.DisplayName(@"Texture Sampling")] public class RenderTextureSamplerSettings : ImageInputSettings
    {
        public string CameraTag { get; set; }
        public UnityEngine.ColorSpace ColorSpace { get; set; }
        public bool FlipFinalOutput { get; set; }
        protected override System.Type InputType { get; }
        public override int OutputHeight { get; set; }
        public override int OutputWidth { get; set; }
        public int RenderHeight { get; set; }
        public int RenderWidth { get; set; }
        public SuperSamplingCount SuperSampling { get; set; }
        public RenderTextureSamplerSettings() {}
        protected override void CheckForWarnings(System.Collections.Generic.List<string> warnings);
    }

    public abstract class StandardImageInputSettings : ImageInputSettings
    {
        public override int OutputHeight { get; set; }
        public override int OutputWidth { get; set; }
        protected StandardImageInputSettings() {}
        protected override void CheckForErrors(System.Collections.Generic.List<string> errors);
        protected override void CheckForWarnings(System.Collections.Generic.List<string> warnings);
    }

    public enum SuperSamplingCount
    {
        X1 = 1,
        X16 = 16,
        X2 = 2,
        X4 = 4,
        X8 = 8,
    }
}

namespace UnityEditor.Recorder.Timeline
{
    [System.ComponentModel.DisplayName(@"Recorder Clip")] public class RecorderClip : UnityEngine.Playables.PlayableAsset, UnityEngine.ISerializationCallbackReceiver, UnityEngine.Timeline.ITimelineClipAsset
    {
        [UnityEngine.SerializeField] public RecorderSettings settings;
        public UnityEngine.Timeline.ClipCaps clipCaps { get; }
        public RecorderClip() {}
        public override UnityEngine.Playables.Playable CreatePlayable(UnityEngine.Playables.PlayableGraph graph, UnityEngine.GameObject owner);
        public void OnAfterDeserialize();
        public void OnBeforeSerialize();
        public void OnDestroy();
    }

    [UnityEngine.Timeline.TrackClipType(typeof(RecorderClip))] [UnityEngine.Timeline.TrackColor(0f, 0.53f, 0.08f)] public class RecorderTrack : UnityEngine.Timeline.TrackAsset
    {
        public RecorderTrack() {}
    }
}