Set everything to internal (for the time being)

com.unity.vfx-toolbox/Editor/Canvas/VFXToolboxCanvas.cs

 
 namespace UnityEditor.VFXToolbox
 {
-    public abstract class VFXToolboxCanvas
+    internal abstract class VFXToolboxCanvas
     {
         public Rect displayRect
         {

com.unity.vfx-toolbox/Editor/External/CurveEditor.cs

 
 namespace UnityEditor.VFXToolbox
 {
-    public sealed class CurveEditor
+    internal sealed class CurveEditor
     {
         #region Enums
 

com.unity.vfx-toolbox/Editor/Utility/CurveDrawer.cs

 
 namespace UnityEditor.VFXToolbox
 {
-    public class CurveDrawer
+    internal class CurveDrawer
     {
         private string m_CurveEditName;
         private int m_WidgetDefaultHeight;

com.unity.vfx-toolbox/Editor/Utility/CurveToTextureUtility.cs

 
 namespace UnityEditor.VFXToolbox
 {
-    public class CurveToTextureUtility
+    internal class CurveToTextureUtility
     {
         public static void CurveToTexture(AnimationCurve curve, ref Texture2D texture)
         {

com.unity.vfx-toolbox/Editor/Utility/FilterPopupWindow.cs

 
 namespace UnityEditor.VFXToolbox
 {
-    public interface IProvider
+    internal interface IProvider
     {
         void CreateComponentTree(List<FilterPopupWindow.Element> tree);
         bool GoToChild(FilterPopupWindow.Element element, bool addIfComponent);
-    public class FilterPopupWindow : EditorWindow
+    internal class FilterPopupWindow : EditorWindow
     {
         public static readonly float DefaultWidth = 240f;
         public static readonly float DefaultHeight = 300f;

com.unity.vfx-toolbox/Editor/Utility/FloatSliderPropertyDrawer.cs

 namespace UnityEditor.VFXToolbox
 {
     [CustomPropertyDrawer(typeof(FloatSliderAttribute))]
-    public class FloatSliderPropertyDrawer : PropertyDrawer
+    internal class FloatSliderPropertyDrawer : PropertyDrawer
     {
         public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
         {

com.unity.vfx-toolbox/Editor/Utility/Splitter.cs

 
 namespace UnityEditor.VFXToolbox
 {
-    public class Splitter
+    internal class Splitter
     {
         public enum SplitLockMode
         {

com.unity.vfx-toolbox/Editor/Utility/VFXToolboxGUIUtility.cs

 
 namespace UnityEditor.VFXToolbox
 {
-    class VFXToolboxGUIUtility
+    internal class VFXToolboxGUIUtility
     {
         #region GUIContent caching
         private static Dictionary<string, GUIContent> s_GUIContentCache;

com.unity.vfx-toolbox/Editor/Utility/VFXToolboxStyles.cs

 
 namespace UnityEditor.VFXToolbox
 {
-    public static class VFXToolboxStyles
+    internal static class VFXToolboxStyles
     {
         // Custom Toggleable Header (in VFXToolboxGUIUtility)
         public static GUIStyle Header;

com.unity.vfx-toolbox/Editor/Utility/VFXToolboxUtility.cs

 
 namespace UnityEditor.VFXToolbox
 {
-    public class VFXToolboxUtility
+    internal class VFXToolboxUtility
     {
         #region Readback utils
 

com.unity.vfx-toolbox/ImageSequencer/Editor/FilterPopup/ProcessorDataProvider.cs

 
 namespace UnityEditor.VFXToolbox.ImageSequencer
 {
-    public class ProcessorDataProvider : IProvider
+    internal class ProcessorDataProvider : IProvider
     {
         private Dictionary<Type, ProcessorAttribute> m_dataSource;
         private FrameProcessorStack m_processorStack;

com.unity.vfx-toolbox/ImageSequencer/Editor/FrameProcessor.cs

 
 namespace UnityEditor.VFXToolbox.ImageSequencer
 {
-    public abstract class FrameProcessor
+    internal abstract class FrameProcessor
     {
         public int OutputWidth
         {
 
     }
 
-    public abstract class FrameProcessor<T> : FrameProcessor where T : ProcessorSettingsBase
+    internal abstract class FrameProcessor<T> : FrameProcessor where T : ProcessorSettingsBase
     {
         public T settings { get { return m_Settings; } private set { m_Settings = value;  m_SerializedObject = new SerializedObject(m_Settings); } }
 

com.unity.vfx-toolbox/ImageSequencer/Editor/FrameProcessorStack.Serialization.cs

 
 namespace UnityEditor.VFXToolbox.ImageSequencer
 {
-    public partial class FrameProcessorStack
+    internal partial class FrameProcessorStack
     {
         public void AddSettingsObjectToAsset(ImageSequence asset, ScriptableObject settings)
         {

com.unity.vfx-toolbox/ImageSequencer/Editor/FrameProcessorStack.cs

 
 namespace UnityEditor.VFXToolbox.ImageSequencer
 {
-    public partial class FrameProcessorStack
+    internal partial class FrameProcessorStack
     {
         public ProcessingFrameSequence inputSequence
         {

com.unity.vfx-toolbox/ImageSequencer/Editor/GPUFrameProcessor.cs

 
 namespace UnityEditor.VFXToolbox.ImageSequencer
 {
-    public abstract class GPUFrameProcessor<T> : FrameProcessor<T> where T : ProcessorSettingsBase
+    internal abstract class GPUFrameProcessor<T> : FrameProcessor<T> where T : ProcessorSettingsBase
     {
         protected Shader m_Shader;
         protected Material m_Material;

com.unity.vfx-toolbox/ImageSequencer/Editor/ImageSequenceAssetEditor.cs

 namespace UnityEditor.VFXToolbox.ImageSequencer
 {
     [CustomEditor(typeof(ImageSequence))]
-    public class ImageSequenceAssetEditor : Editor
+    internal class ImageSequenceAssetEditor : Editor
     {
         private bool m_PreviewInput = false;
         private bool m_PreviewOutput = false;

com.unity.vfx-toolbox/ImageSequencer/Editor/ImageSequenceAssetFactory.cs

 
 namespace UnityEditor.VFXToolbox.ImageSequencer
 {
-    public class ImageSequenceAssetFactory
+    internal class ImageSequenceAssetFactory
     {
         [MenuItem("Assets/Create/Visual Effects/Image Sequence", priority = 301)]
         private static void MenuCreatePostProcessingProfile()
         }
     }
 
-    public class ImageSequenceAssetCallbackHandler
+    internal class ImageSequenceAssetCallbackHandler
     {
         [OnOpenAsset(1)]
         public static bool OpenImageSequenceAsset(int instanceID, int line)

com.unity.vfx-toolbox/ImageSequencer/Editor/ImageSequencer.Export.cs

 
 namespace UnityEditor.VFXToolbox.ImageSequencer
 {
-    public partial class ImageSequencer : EditorWindow
+    internal partial class ImageSequencer : EditorWindow
     {
         private string GetNumberedFileName(string pattern, int number, int maxFrames)
         {

com.unity.vfx-toolbox/ImageSequencer/Editor/ImageSequencer.GUI.cs

 
 namespace UnityEditor.VFXToolbox.ImageSequencer
 {
-    public partial class ImageSequencer : EditorWindow
+    internal partial class ImageSequencer : EditorWindow
     {
         private Splitter m_Splitter;
         private ReorderableList m_InputFramesReorderableList;

com.unity.vfx-toolbox/ImageSequencer/Editor/ImageSequencer.InputFrames.cs

 
 namespace UnityEditor.VFXToolbox.ImageSequencer
 {
-    public partial class ImageSequencer : EditorWindow
+    internal partial class ImageSequencer : EditorWindow
     {
 
         private int m_InputFramesHashCode;

com.unity.vfx-toolbox/ImageSequencer/Editor/ImageSequencer.Processors.cs

 
 namespace UnityEditor.VFXToolbox.ImageSequencer
 {
-    public partial class ImageSequencer : EditorWindow
+    internal partial class ImageSequencer : EditorWindow
     {
         [System.NonSerialized]
         ProcessorDataProvider m_ProcessorDataProvider;

com.unity.vfx-toolbox/ImageSequencer/Editor/ImageSequencer.Styles.cs

 
 namespace UnityEditor.VFXToolbox.ImageSequencer
 {
-    public partial class ImageSequencer : EditorWindow
+    internal partial class ImageSequencer : EditorWindow
     {
         static Styles s_Styles = null;
         public static Styles styles { get { if (s_Styles == null) s_Styles = new Styles(); return s_Styles; } }

com.unity.vfx-toolbox/ImageSequencer/Editor/ImageSequencer.cs

 
 namespace UnityEditor.VFXToolbox.ImageSequencer
 {
-    public partial class ImageSequencer : EditorWindow
+    internal partial class ImageSequencer : EditorWindow
     {
         [MenuItem("Window/Visual Effects/Image Sequencer")]
         public static void OpenEditor()

com.unity.vfx-toolbox/ImageSequencer/Editor/ImageSequencerCanvas.cs

 
 namespace UnityEditor.VFXToolbox.ImageSequencer
 {
-    public class ImageSequencerCanvas : VFXToolboxCanvas
+    internal class ImageSequencerCanvas : VFXToolboxCanvas
     {
 
         public bool showExtraInfo

com.unity.vfx-toolbox/ImageSequencer/Editor/ProcessingFrame.cs

 
 namespace UnityEditor.VFXToolbox.ImageSequencer
 {
-    public class ProcessingFrame
+    internal class ProcessingFrame
     {
         public Texture texture
         {

com.unity.vfx-toolbox/ImageSequencer/Editor/ProcessingFrameSequence.cs

 
 namespace UnityEditor.VFXToolbox.ImageSequencer
 {
-    public class ProcessingFrameSequence
+    internal class ProcessingFrameSequence
     {
         public int numU
         {

com.unity.vfx-toolbox/ImageSequencer/Editor/Processors/AssembleProcessor.cs

 
 namespace UnityEditor.VFXToolbox.ImageSequencer
 {
-    public class AssembleProcessor : GPUFrameProcessor<AssembleProcessorSettings>
+    class AssembleProcessor : GPUFrameProcessor<AssembleProcessorSettings>
     {
         public AssembleProcessor(FrameProcessorStack processorStack, ProcessorInfo info)
             : base ("Packages/com.unity.vfx-toolbox/ImageSequencer/Editor/Shaders/AssembleBlit.shader", processorStack, info)

com.unity.vfx-toolbox/ImageSequencer/Editor/Processors/BreakFilpbookProcessor.cs

 
 namespace UnityEditor.VFXToolbox.ImageSequencer
 {
-    public class BreakFlipbookProcessor : GPUFrameProcessor<BreakFilpbookProcessorSettings>
+    class BreakFlipbookProcessor : GPUFrameProcessor<BreakFilpbookProcessorSettings>
     {
         private bool m_BypassSecurityCheck = false;
 

com.unity.vfx-toolbox/ImageSequencer/Editor/Processors/CropProcessor.cs

 {
     class CropProcessor : GPUFrameProcessor<CropProcessorSettings>
     {
-
         public CropProcessor(FrameProcessorStack stack, ProcessorInfo info) 
             : base("Packages/com.unity.vfx-toolbox/ImageSequencer/Editor/Shaders/Crop.shader", stack, info)
         { }

com.unity.vfx-toolbox/ImageSequencer/Editor/Processors/CustomMaterialProcessor.cs

 
 namespace UnityEditor.VFXToolbox.ImageSequencer
 {
-    public class CustomMaterialProcessor : GPUFrameProcessor<CustomMaterialProcessorSettings>
+    class CustomMaterialProcessor : GPUFrameProcessor<CustomMaterialProcessorSettings>
     {
         private Editor m_MaterialEditor;
         private Shader m_CachedShader; 

com.unity.vfx-toolbox/ImageSequencer/Editor/Processors/FadeProcessor.cs

 
 namespace UnityEditor.VFXToolbox.ImageSequencer
 {
-    public class FadeProcessor : GPUFrameProcessor<FadeProcessorSettings>
+    class FadeProcessor : GPUFrameProcessor<FadeProcessorSettings>
     {
         CurveDrawer m_CurveDrawer;
 

com.unity.vfx-toolbox/ImageSequencer/Editor/Processors/LoopingProcessor.cs

 
 namespace UnityEditor.VFXToolbox.ImageSequencer
 {
-    public class LoopingProcessor : GPUFrameProcessor<LoopingProcessorSettings>
+    class LoopingProcessor : GPUFrameProcessor<LoopingProcessorSettings>
     {
         CurveDrawer m_CurveDrawer;
 

com.unity.vfx-toolbox/ImageSequencer/Editor/Processors/RemoveBackgroundBlendingProcessor.cs

 
 namespace UnityEditor.VFXToolbox.ImageSequencer
 {
-    public class RemoveBackgroundBlendingProcessor : GPUFrameProcessor<RemoveBackgroundSettings>
+    class RemoveBackgroundBlendingProcessor : GPUFrameProcessor<RemoveBackgroundSettings>
     {
 
         public RemoveBackgroundBlendingProcessor(FrameProcessorStack processorStack, ProcessorInfo info)

com.unity.vfx-toolbox/ImageSequencer/Editor/Processors/RetimeProcessor.cs

 
 namespace UnityEditor.VFXToolbox.ImageSequencer
 {
-    public class RetimeProcessor : GPUFrameProcessor<RetimeProcessorSettings>
+    class RetimeProcessor : GPUFrameProcessor<RetimeProcessorSettings>
     {
         CurveDrawer m_CurveDrawer;
 

com.unity.vfx-toolbox/ImageSequencer/Editor/Processors/RotateProcessor.cs

 
 namespace UnityEditor.VFXToolbox.ImageSequencer
 {
-    public class RotateProcessor : GPUFrameProcessor<RotateProcessorSettings>
+    class RotateProcessor : GPUFrameProcessor<RotateProcessorSettings>
     {
 
         public RotateProcessor(FrameProcessorStack processorStack, ProcessorInfo info)

com.unity.vfx-toolbox/ImageSequencer/Editor/Serialization/Processors/DecimateProcessorSettings.cs

 namespace UnityEditor.VFXToolbox.ImageSequencer
 {
     [Processor("Sequence","Decimate", typeof(DecimateProcessor))]
-    public class DecimateProcessorSettings : ProcessorSettingsBase
+    class DecimateProcessorSettings : ProcessorSettingsBase
     {
         public ushort DecimateBy;
 

com.unity.vfx-toolbox/ImageSequencer/Editor/Serialization/Processors/FixBordersProcessorSettings.cs

 namespace UnityEditor.VFXToolbox.ImageSequencer
 {
     [Processor("Common","Fix Borders", typeof(FixBordersProcessor))]
-    public class FixBordersProcessorSettings : ProcessorSettingsBase
+    class FixBordersProcessorSettings : ProcessorSettingsBase
     {
         public Vector4 FixFactors;
         public Color FadeToColor;

com.unity.vfx-toolbox/ImageSequencer/Editor/Serialization/Processors/LoopingProcessorSettings.cs

 namespace UnityEditor.VFXToolbox.ImageSequencer
 {
     [Processor("Sequence","Loop Sequence", typeof(LoopingProcessor))]
-    public class LoopingProcessorSettings : ProcessorSettingsBase
+    class LoopingProcessorSettings : ProcessorSettingsBase
     {
         public AnimationCurve curve;
         public int syncFrame;

com.unity.vfx-toolbox/ImageSequencer/Editor/Serialization/Processors/PremultiplyAlphaProcessorSettings.cs

 namespace UnityEditor.VFXToolbox.ImageSequencer
 {
     [Processor("Color","Premultiply Alpha", typeof(PremultiplyAlphaProcessor))]
-    public class PremultiplyAlphaProcessorSettings : ProcessorSettingsBase
+    class PremultiplyAlphaProcessorSettings : ProcessorSettingsBase
     {
         public bool RemoveAlpha;
         public float AlphaValue;

com.unity.vfx-toolbox/ImageSequencer/Editor/Serialization/Processors/RemapColorProcessorSettings.cs

 namespace UnityEditor.VFXToolbox.ImageSequencer
 {
     [Processor("Color","Remap Color", typeof(RemapColorProcessor))]
-    public class RemapColorProcessorSettings : ProcessorSettingsBase
+    class RemapColorProcessorSettings : ProcessorSettingsBase
     {
         public enum RemapColorSource
         {

com.unity.vfx-toolbox/ImageSequencer/Editor/Serialization/Processors/RemoveBackgroundSettings.cs

 namespace UnityEditor.VFXToolbox.ImageSequencer
 {
     [Processor("Color","Remove Background", typeof(RemoveBackgroundBlendingProcessor))]
-    public class RemoveBackgroundSettings : ProcessorSettingsBase
+    class RemoveBackgroundSettings : ProcessorSettingsBase
     {
         public Color BackgroundColor;
 

com.unity.vfx-toolbox/ImageSequencer/Editor/Serialization/Processors/ResizeProcessorSettings.cs

 namespace UnityEditor.VFXToolbox.ImageSequencer
 {
     [Processor("Common","Resize", typeof(ResizeProcessor))]
-    public class ResizeProcessorSettings : ProcessorSettingsBase
+    class ResizeProcessorSettings : ProcessorSettingsBase
     {
         public ushort Width;
         public ushort Height;

com.unity.vfx-toolbox/ImageSequencer/Editor/Serialization/Processors/RetimeProcessorSettings.cs

 namespace UnityEditor.VFXToolbox.ImageSequencer
 {
     [Processor("Sequence","Retime", typeof(RetimeProcessor))]
-    public class RetimeProcessorSettings : ProcessorSettingsBase
+    class RetimeProcessorSettings : ProcessorSettingsBase
     {
         public AnimationCurve curve;
         public int outputSequenceLength;

com.unity.vfx-toolbox/ImageSequencer/Editor/Serialization/Processors/RotateProcessorSettings.cs

 namespace UnityEditor.VFXToolbox.ImageSequencer
 {
     [Processor("Common","Rotate", typeof(RotateProcessor))]
-    public class RotateProcessorSettings : ProcessorSettingsBase
+    class RotateProcessorSettings : ProcessorSettingsBase
     {
         public enum RotateMode
         {

com.unity.vfx-toolbox/ImageSequencer/Editor/Public.meta

+fileFormatVersion: 2
+guid: 587f081463041004ca4b2a3454fe1840
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: