/*
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 * All rights reserved.
 *
 * Licensed under the Oculus SDK License Agreement (the "License");
 * you may not use the Oculus SDK except in compliance with the License,
 * which is provided at the time of installation or download, or which
 * otherwise accompanies this software in either electronic or hard copy form.
 *
 * You may obtain a copy of the License at
 *
 * https://developer.oculus.com/licenses/oculussdk/
 *
 * Unless required by applicable law or agreed to in writing, the Oculus SDK
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

//This file was auto generated.
using UnityEditor;
using Oculus.Interaction.Editor;

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(TubeRenderer), false, isFallback = true)]
    public class TubeRendererEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(GrabStrengthIndicator), false, isFallback = true)]
    public class GrabStrengthIndicatorEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(Axis1DSwitch), false, isFallback = true)]
    public class Axis1DSwitchEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(ActiveStateGate), false, isFallback = true)]
    public class ActiveStateGateEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(ActiveStateGroup), false, isFallback = true)]
    public class ActiveStateGroupEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(ActiveStateNot), false, isFallback = true)]
    public class ActiveStateNotEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(ActiveStateSelector), false, isFallback = true)]
    public class ActiveStateSelectorEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(ActiveStateTracker), false, isFallback = true)]
    public class ActiveStateTrackerEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(Axis2DActiveState), false, isFallback = true)]
    public class Axis2DActiveStateEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(BestHoverInteractorGroup), false, isFallback = true)]
    public class BestHoverInteractorGroupEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(BestSelectInteractorGroup), false, isFallback = true)]
    public class BestSelectInteractorGroupEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(CandidatePositionComparer), false, isFallback = true)]
    public class CandidatePositionComparerEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(ControllerActiveState), false, isFallback = true)]
    public class ControllerActiveStateEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(FirstHoverInteractorGroup), false, isFallback = true)]
    public class FirstHoverInteractorGroupEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(GameObjectActiveState), false, isFallback = true)]
    public class GameObjectActiveStateEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(HandActiveState), false, isFallback = true)]
    public class HandActiveStateEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(InteractableGroup), false, isFallback = true)]
    public class InteractableGroupEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(InteractableGroupView), false, isFallback = true)]
    public class InteractableGroupViewEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(InteractableTriggerBroadcaster), false, isFallback = true)]
    public class InteractableTriggerBroadcasterEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(InteractorActiveState), false, isFallback = true)]
    public class InteractorActiveStateEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(SecondaryInteractorConnection), false, isFallback = true)]
    public class SecondaryInteractorConnectionEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(SecondaryInteractorFilter), false, isFallback = true)]
    public class SecondaryInteractorFilterEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(TagSet), false, isFallback = true)]
    public class TagSetEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(TagSetFilter), false, isFallback = true)]
    public class TagSetFilterEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(UpdateDriverAfterDataSource), false, isFallback = true)]
    public class UpdateDriverAfterDataSourceEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(UpdateDriverGroup), false, isFallback = true)]
    public class UpdateDriverGroupEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(Grabbable), false, isFallback = true)]
    public class GrabbableEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(OneGrabFreeTransformer), false, isFallback = true)]
    public class OneGrabFreeTransformerEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(OneGrabPhysicsJointTransformer), false, isFallback = true)]
    public class OneGrabPhysicsJointTransformerEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(OneGrabRotateTransformer), false, isFallback = true)]
    public class OneGrabRotateTransformerEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(OneGrabTranslateTransformer), false, isFallback = true)]
    public class OneGrabTranslateTransformerEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(TwoGrabFreeTransformer), false, isFallback = true)]
    public class TwoGrabFreeTransformerEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(TwoGrabPlaneTransformer), false, isFallback = true)]
    public class TwoGrabPlaneTransformerEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(TwoGrabRotateTransformer), false, isFallback = true)]
    public class TwoGrabRotateTransformerEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(DistanceGrabInteractable), false, isFallback = true)]
    public class DistanceGrabInteractableEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(DistanceGrabInteractor), false, isFallback = true)]
    public class DistanceGrabInteractorEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(GrabInteractable), false, isFallback = true)]
    public class GrabInteractableEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(GrabInteractor), false, isFallback = true)]
    public class GrabInteractorEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(PokeInteractable), false, isFallback = true)]
    public class PokeInteractableEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(PokeInteractor), false, isFallback = true)]
    public class PokeInteractorEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(HandPokeLimiterVisual), false, isFallback = true)]
    public class HandPokeLimiterVisualEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(PokeInteractableVisual), false, isFallback = true)]
    public class PokeInteractableVisualEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(RayInteractable), false, isFallback = true)]
    public class RayInteractableEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(RayInteractor), false, isFallback = true)]
    public class RayInteractorEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(ControllerRayVisual), false, isFallback = true)]
    public class ControllerRayVisualEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(HandRayInteractorCursorVisual), false, isFallback = true)]
    public class HandRayInteractorCursorVisualEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(RayInteractorCursorVisual), false, isFallback = true)]
    public class RayInteractorCursorVisualEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(RayInteractorDebugGizmos), false, isFallback = true)]
    public class RayInteractorDebugGizmosEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(RayInteractorPinchVisual), false, isFallback = true)]
    public class RayInteractorPinchVisualEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(ListSnapPoseDelegate), false, isFallback = true)]
    public class ListSnapPoseDelegateEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(SequentialSlotsProvider), false, isFallback = true)]
    public class SequentialSlotsProviderEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(SnapInteractable), false, isFallback = true)]
    public class SnapInteractableEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(SnapInteractor), false, isFallback = true)]
    public class SnapInteractorEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(SurfaceSnapPoseDelegate), false, isFallback = true)]
    public class SurfaceSnapPoseDelegateEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(SnapInteractorFollowVisual), false, isFallback = true)]
    public class SnapInteractorFollowVisualEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(HandSphereMap), false, isFallback = true)]
    public class HandSphereMapEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(TouchHandGrabInteractable), false, isFallback = true)]
    public class TouchHandGrabInteractableEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(TouchHandGrabInteractor), false, isFallback = true)]
    public class TouchHandGrabInteractorEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(TouchHandGrabInteractorVisual), false, isFallback = true)]
    public class TouchHandGrabInteractorVisualEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(Axis1DFingerUseAPI), false, isFallback = true)]
    public class Axis1DFingerUseAPIEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(UseFingerCurlAPI), false, isFallback = true)]
    public class UseFingerCurlAPIEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(UseFingerRawPinchAPI), false, isFallback = true)]
    public class UseFingerRawPinchAPIEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(PointableDebugGizmos), false, isFallback = true)]
    public class PointableDebugGizmosEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(PointableDebugVisual), false, isFallback = true)]
    public class PointableDebugVisualEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(PointableElement), false, isFallback = true)]
    public class PointableElementEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(VirtualPointable), false, isFallback = true)]
    public class VirtualPointableEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(BecomeChildOfTargetOnStart), false, isFallback = true)]
    public class BecomeChildOfTargetOnStartEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(HandConfidenceVisual), false, isFallback = true)]
    public class HandConfidenceVisualEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(HandDebugVisual), false, isFallback = true)]
    public class HandDebugVisualEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(HandVisual), false, isFallback = true)]
    public class HandVisualEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(InteractableColorVisual), false, isFallback = true)]
    public class InteractableColorVisualEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(InteractableDebugVisual), false, isFallback = true)]
    public class InteractableDebugVisualEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(InteractorDebugVisual), false, isFallback = true)]
    public class InteractorDebugVisualEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(SelectorDebugVisual), false, isFallback = true)]
    public class SelectorDebugVisualEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(DotGridProperties), false, isFallback = true)]
    public class DotGridPropertiesEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(MaterialPropertyBlockEditor), false, isFallback = true)]
    public class MaterialPropertyBlockEditorEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(RoundedBoxProperties), false, isFallback = true)]
    public class RoundedBoxPropertiesEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(DebugGizmos), false, isFallback = true)]
    public class DebugGizmosEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(FingerFeatureStateProviderRef), false, isFallback = true)]
    public class FingerFeatureStateProviderRefEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(JointDeltaProviderRef), false, isFallback = true)]
    public class JointDeltaProviderRefEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(TransformFeatureStateProviderRef), false, isFallback = true)]
    public class TransformFeatureStateProviderRefEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(ControllerOffset), false, isFallback = true)]
    public class ControllerOffsetEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(ControllerPointerPose), false, isFallback = true)]
    public class ControllerPointerPoseEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(ControllerSelector), false, isFallback = true)]
    public class ControllerSelectorEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(ConicalFrustum), false, isFallback = true)]
    public class ConicalFrustumEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(FingerPinchValue), false, isFallback = true)]
    public class FingerPinchValueEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(HandJoint), false, isFallback = true)]
    public class HandJointEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(HandJointsPose), false, isFallback = true)]
    public class HandJointsPoseEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(HandPinchOffset), false, isFallback = true)]
    public class HandPinchOffsetEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(HandPointerPose), false, isFallback = true)]
    public class HandPointerPoseEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(HandTransformScaler), false, isFallback = true)]
    public class HandTransformScalerEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(HandWristOffset), false, isFallback = true)]
    public class HandWristOffsetEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(IndexPinchSafeReleaseSelector), false, isFallback = true)]
    public class IndexPinchSafeReleaseSelectorEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(IndexPinchSelector), false, isFallback = true)]
    public class IndexPinchSelectorEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(ShoulderEstimatePosition), false, isFallback = true)]
    public class ShoulderEstimatePositionEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(VirtualSelector), false, isFallback = true)]
    public class VirtualSelectorEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(Cylinder), false, isFallback = true)]
    public class CylinderEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(ActiveStateUnityEventWrapper), false, isFallback = true)]
    public class ActiveStateUnityEventWrapperEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(InteractableUnityEventWrapper), false, isFallback = true)]
    public class InteractableUnityEventWrapperEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(InteractorUnityEventWrapper), false, isFallback = true)]
    public class InteractorUnityEventWrapperEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(PhysicsGrabbable), false, isFallback = true)]
    public class PhysicsGrabbableEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(PointableCanvas), false, isFallback = true)]
    public class PointableCanvasEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(PointableCanvasMesh), false, isFallback = true)]
    public class PointableCanvasMeshEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(PointableCanvasModule), false, isFallback = true)]
    public class PointableCanvasModuleEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(PointableCanvasUnityEventWrapper), false, isFallback = true)]
    public class PointableCanvasUnityEventWrapperEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(PointableUnityEventWrapper), false, isFallback = true)]
    public class PointableUnityEventWrapperEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(SelectorUnityEventWrapper), false, isFallback = true)]
    public class SelectorUnityEventWrapperEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(ToggleDeselect), false, isFallback = true)]
    public class ToggleDeselectEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Editor.Generated
{
    [CustomEditor(typeof(VersionTextVisual), false, isFallback = true)]
    public class VersionTextVisualEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.UnityCanvas.Editor.Generated
{
    [CustomEditor(typeof(CanvasCylinder), false, isFallback = true)]
    public class CanvasCylinderEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.UnityCanvas.Editor.Generated
{
    [CustomEditor(typeof(CanvasMeshRenderer), false, isFallback = true)]
    public class CanvasMeshRendererEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.UnityCanvas.Editor.Generated
{
    [CustomEditor(typeof(CanvasRect), false, isFallback = true)]
    public class CanvasRectEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.UnityCanvas.Editor.Generated
{
    [CustomEditor(typeof(CanvasRenderTexture), false, isFallback = true)]
    public class CanvasRenderTextureEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.UnityCanvas.Editor.Generated
{
    [CustomEditor(typeof(UpdateCanvasSortingOrder), false, isFallback = true)]
    public class UpdateCanvasSortingOrderEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Unity.Input.Editor.Generated
{
    [CustomEditor(typeof(InputAxis), false, isFallback = true)]
    public class InputAxisEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Unity.Input.Editor.Generated
{
    [CustomEditor(typeof(InputButton), false, isFallback = true)]
    public class InputButtonEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Unity.Input.Editor.Generated
{
    [CustomEditor(typeof(InputKey), false, isFallback = true)]
    public class InputKeyEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Unity.Input.Editor.Generated
{
    [CustomEditor(typeof(InputMouseButton), false, isFallback = true)]
    public class InputMouseButtonEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Throw.Editor.Generated
{
    [CustomEditor(typeof(ControllerPoseInputDevice), false, isFallback = true)]
    public class ControllerPoseInputDeviceEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Throw.Editor.Generated
{
    [CustomEditor(typeof(HandPoseInputDevice), false, isFallback = true)]
    public class HandPoseInputDeviceEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Throw.Editor.Generated
{
    [CustomEditor(typeof(StandardVelocityCalculator), false, isFallback = true)]
    public class StandardVelocityCalculatorEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Surfaces.Editor.Generated
{
    [CustomEditor(typeof(AxisAlignedBox), false, isFallback = true)]
    public class AxisAlignedBoxEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Surfaces.Editor.Generated
{
    [CustomEditor(typeof(BoundsClipper), false, isFallback = true)]
    public class BoundsClipperEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Surfaces.Editor.Generated
{
    [CustomEditor(typeof(CircleSurface), false, isFallback = true)]
    public class CircleSurfaceEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Surfaces.Editor.Generated
{
    [CustomEditor(typeof(ClippedCylinderSurface), false, isFallback = true)]
    public class ClippedCylinderSurfaceEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Surfaces.Editor.Generated
{
    [CustomEditor(typeof(ClippedPlaneSurface), false, isFallback = true)]
    public class ClippedPlaneSurfaceEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Surfaces.Editor.Generated
{
    [CustomEditor(typeof(ColliderSurface), false, isFallback = true)]
    public class ColliderSurfaceEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Surfaces.Editor.Generated
{
    [CustomEditor(typeof(CylinderClipper), false, isFallback = true)]
    public class CylinderClipperEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Surfaces.Editor.Generated
{
    [CustomEditor(typeof(CylinderSurface), false, isFallback = true)]
    public class CylinderSurfaceEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Surfaces.Editor.Generated
{
    [CustomEditor(typeof(NavMeshSurface), false, isFallback = true)]
    public class NavMeshSurfaceEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Surfaces.Editor.Generated
{
    [CustomEditor(typeof(PlaneSurface), false, isFallback = true)]
    public class PlaneSurfaceEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Locomotion.Editor.Generated
{
    [CustomEditor(typeof(VirtualActiveState), false, isFallback = true)]
    public class VirtualActiveStateEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Locomotion.Editor.Generated
{
    [CustomEditor(typeof(LocomotionEventsConnection), false, isFallback = true)]
    public class LocomotionEventsConnectionEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Locomotion.Editor.Generated
{
    [CustomEditor(typeof(PlayerLocomotor), false, isFallback = true)]
    public class PlayerLocomotorEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Locomotion.Editor.Generated
{
    [CustomEditor(typeof(TeleportArcGravity), false, isFallback = true)]
    public class TeleportArcGravityEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Locomotion.Editor.Generated
{
    [CustomEditor(typeof(TeleportInteractable), false, isFallback = true)]
    public class TeleportInteractableEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Locomotion.Editor.Generated
{
    [CustomEditor(typeof(TeleportInteractor), false, isFallback = true)]
    public class TeleportInteractorEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Locomotion.Editor.Generated
{
    [CustomEditor(typeof(LocomotionGate), false, isFallback = true)]
    public class TeleportTurningGateEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Locomotion.Editor.Generated
{
    [CustomEditor(typeof(TeleportArcVisual), false, isFallback = true)]
    public class TeleportArcVisualEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Locomotion.Editor.Generated
{
    [CustomEditor(typeof(TeleportProceduralArcVisual), false, isFallback = true)]
    public class TeleportProceduralArcVisualEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Locomotion.Editor.Generated
{
    [CustomEditor(typeof(LocomotionAxisTurnerInteractor), false, isFallback = true)]
    public class LocomotionAxisTurnerInteractorEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Locomotion.Editor.Generated
{
    [CustomEditor(typeof(LocomotionTurnerInteractor), false, isFallback = true)]
    public class LocomotionTurnerInteractorEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Locomotion.Editor.Generated
{
    [CustomEditor(typeof(LocomotionTurnerInteractorEventsWrapper), false, isFallback = true)]
    public class LocomotionTurnerInteractorEventsWrapperEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Locomotion.Editor.Generated
{
    [CustomEditor(typeof(LocomotionTurnerInteractorVisual), false, isFallback = true)]
    public class LocomotionTurnerInteractorVisualEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Locomotion.Editor.Generated
{
    [CustomEditor(typeof(TurnerEventBroadcaster), false, isFallback = true)]
    public class TurnerEventBroadcasterEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Utils.Editor.Generated
{
    [CustomEditor(typeof(FilteredTransform), false, isFallback = true)]
    public class FilteredTransformEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Input.Editor.Generated
{
    [CustomEditor(typeof(Controller), false, isFallback = true)]
    public class ControllerEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Input.Editor.Generated
{
    [CustomEditor(typeof(ControllerButtonUsageActiveState), false, isFallback = true)]
    public class ControllerButtonUsageActiveStateEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Input.Editor.Generated
{
    [CustomEditor(typeof(ControllerRef), false, isFallback = true)]
    public class ControllerRefEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Input.Editor.Generated
{
    [CustomEditor(typeof(Hmd), false, isFallback = true)]
    public class HmdEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Input.Editor.Generated
{
    [CustomEditor(typeof(HmdRef), false, isFallback = true)]
    public class HmdRefEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Input.Editor.Generated
{
    [CustomEditor(typeof(FixedScaleHand), false, isFallback = true)]
    public class FixedScaleHandEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Input.Editor.Generated
{
    [CustomEditor(typeof(JointRotationHistoryHand), false, isFallback = true)]
    public class JointRotationHistoryHandEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Input.Editor.Generated
{
    [CustomEditor(typeof(LastKnownGoodHand), false, isFallback = true)]
    public class LastKnownGoodHandEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Input.Editor.Generated
{
    [CustomEditor(typeof(SyntheticHand), false, isFallback = true)]
    public class SyntheticHandEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Input.Editor.Generated
{
    [CustomEditor(typeof(FromHandPrefabDataSource), false, isFallback = true)]
    public class FromHandPrefabDataSourceEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Input.Editor.Generated
{
    [CustomEditor(typeof(Hand), false, isFallback = true)]
    public class HandEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Input.Editor.Generated
{
    [CustomEditor(typeof(HandPhysicsCapsules), false, isFallback = true)]
    public class HandPhysicsCapsulesEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Input.Editor.Generated
{
    [CustomEditor(typeof(HandRef), false, isFallback = true)]
    public class HandRefEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Input.Editor.Generated
{
    [CustomEditor(typeof(JointsRadiusFeature), false, isFallback = true)]
    public class JointsRadiusFeatureEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Input.Filter.Editor.Generated
{
    [CustomEditor(typeof(HandFilter), false, isFallback = true)]
    public class HandFilterEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.HandGrab.Editor.Generated
{
    [CustomEditor(typeof(HandGrabStateVisual), false, isFallback = true)]
    public class HandGrabStateVisualEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.HandGrab.Editor.Generated
{
    [CustomEditor(typeof(DistanceHandGrabInteractable), false, isFallback = true)]
    public class DistanceHandGrabInteractableEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.HandGrab.Editor.Generated
{
    [CustomEditor(typeof(DistanceHandGrabInteractor), false, isFallback = true)]
    public class DistanceHandGrabInteractorEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.HandGrab.Editor.Generated
{
    [CustomEditor(typeof(HandGrabInteractable), false, isFallback = true)]
    public class HandGrabInteractableEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.HandGrab.Editor.Generated
{
    [CustomEditor(typeof(HandGrabInteractor), false, isFallback = true)]
    public class HandGrabInteractorEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.HandGrab.Editor.Generated
{
    [CustomEditor(typeof(HandGrabPose), false, isFallback = true)]
    public class HandGrabPoseEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.HandGrab.Editor.Generated
{
    [CustomEditor(typeof(HandGrabUseInteractable), false, isFallback = true)]
    public class HandGrabUseInteractableEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.HandGrab.Editor.Generated
{
    [CustomEditor(typeof(HandGrabUseInteractor), false, isFallback = true)]
    public class HandGrabUseInteractorEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.HandGrab.Editor.Generated
{
    [CustomEditor(typeof(AutoMoveTowardsTargetProvider), false, isFallback = true)]
    public class AutoMoveTowardsTargetProviderEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.HandGrab.Editor.Generated
{
    [CustomEditor(typeof(FollowTargetProvider), false, isFallback = true)]
    public class FollowTargetProviderEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.HandGrab.Editor.Generated
{
    [CustomEditor(typeof(MoveAtSourceProvider), false, isFallback = true)]
    public class MoveAtSourceProviderEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.HandGrab.Editor.Generated
{
    [CustomEditor(typeof(MoveFromTargetProvider), false, isFallback = true)]
    public class MoveFromTargetProviderEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.HandGrab.Editor.Generated
{
    [CustomEditor(typeof(MoveTowardsTargetProvider), false, isFallback = true)]
    public class MoveTowardsTargetProviderEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.HandGrab.Editor.Generated
{
    [CustomEditor(typeof(ObjectPullProvider), false, isFallback = true)]
    public class ObjectPullProviderEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.HandGrab.Visuals.Editor.Generated
{
    [CustomEditor(typeof(HandGhost), false, isFallback = true)]
    public class HandGhostEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.HandGrab.Visuals.Editor.Generated
{
    [CustomEditor(typeof(HandPuppet), false, isFallback = true)]
    public class HandPuppetEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Grab.GrabSurfaces.Editor.Generated
{
    [CustomEditor(typeof(BezierGrabSurface), false, isFallback = true)]
    public class BezierGrabSurfaceEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Grab.GrabSurfaces.Editor.Generated
{
    [CustomEditor(typeof(BoxGrabSurface), false, isFallback = true)]
    public class BoxGrabSurfaceEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Grab.GrabSurfaces.Editor.Generated
{
    [CustomEditor(typeof(ColliderGrabSurface), false, isFallback = true)]
    public class ColliderGrabSurfaceEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Grab.GrabSurfaces.Editor.Generated
{
    [CustomEditor(typeof(CylinderGrabSurface), false, isFallback = true)]
    public class CylinderGrabSurfaceEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.Grab.GrabSurfaces.Editor.Generated
{
    [CustomEditor(typeof(SphereGrabSurface), false, isFallback = true)]
    public class SphereGrabSurfaceEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.GrabAPI.Editor.Generated
{
    [CustomEditor(typeof(FingerRawPinchInjector), false, isFallback = true)]
    public class FingerRawPinchInjectorEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.GrabAPI.Editor.Generated
{
    [CustomEditor(typeof(HandGrabAPI), false, isFallback = true)]
    public class HandGrabAPIEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.DistanceReticles.Editor.Generated
{
    [CustomEditor(typeof(DistantInteractionLineRendererVisual), false, isFallback = true)]
    public class DistantInteractionLineRendererVisualEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.DistanceReticles.Editor.Generated
{
    [CustomEditor(typeof(DistantInteractionPolylineVisual), false, isFallback = true)]
    public class DistantInteractionPolylineVisualEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.DistanceReticles.Editor.Generated
{
    [CustomEditor(typeof(DistantInteractionTubeVisual), false, isFallback = true)]
    public class DistantInteractionTubeVisualEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.DistanceReticles.Editor.Generated
{
    [CustomEditor(typeof(ReticleDataGhost), false, isFallback = true)]
    public class ReticleDataGhostEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.DistanceReticles.Editor.Generated
{
    [CustomEditor(typeof(ReticleDataIcon), false, isFallback = true)]
    public class ReticleDataIconEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.DistanceReticles.Editor.Generated
{
    [CustomEditor(typeof(ReticleDataMesh), false, isFallback = true)]
    public class ReticleDataMeshEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.DistanceReticles.Editor.Generated
{
    [CustomEditor(typeof(ReticleGhostDrawer), false, isFallback = true)]
    public class ReticleGhostDrawerEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.DistanceReticles.Editor.Generated
{
    [CustomEditor(typeof(ReticleIconDrawer), false, isFallback = true)]
    public class ReticleIconDrawerEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.DistanceReticles.Editor.Generated
{
    [CustomEditor(typeof(ReticleMeshDrawer), false, isFallback = true)]
    public class ReticleMeshDrawerEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.DistanceReticles.Editor.Generated
{
    [CustomEditor(typeof(ReticleDataTeleport), false, isFallback = true)]
    public class ReticleDataTeleportEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.DistanceReticles.Editor.Generated
{
    [CustomEditor(typeof(TeleportReticleDrawer), false, isFallback = true)]
    public class TeleportReticleDrawerEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.PoseDetection.Editor.Generated
{
    [CustomEditor(typeof(ColliderContainsHandJointActiveState), false, isFallback = true)]
    public class ColliderContainsHandJointActiveStateEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.PoseDetection.Editor.Generated
{
    [CustomEditor(typeof(FingerFeatureStateProvider), false, isFallback = true)]
    public class FingerFeatureStateProviderEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.PoseDetection.Editor.Generated
{
    [CustomEditor(typeof(HmdOffset), false, isFallback = true)]
    public class HmdOffsetEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.PoseDetection.Editor.Generated
{
    [CustomEditor(typeof(JointDeltaProvider), false, isFallback = true)]
    public class JointDeltaProviderEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.PoseDetection.Editor.Generated
{
    [CustomEditor(typeof(JointDistanceActiveState), false, isFallback = true)]
    public class JointDistanceActiveStateEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.PoseDetection.Editor.Generated
{
    [CustomEditor(typeof(JointRotationActiveState), false, isFallback = true)]
    public class JointRotationActiveStateEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.PoseDetection.Editor.Generated
{
    [CustomEditor(typeof(JointVelocityActiveState), false, isFallback = true)]
    public class JointVelocityActiveStateEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.PoseDetection.Editor.Generated
{
    [CustomEditor(typeof(Sequence), false, isFallback = true)]
    public class SequenceEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.PoseDetection.Editor.Generated
{
    [CustomEditor(typeof(SequenceActiveState), false, isFallback = true)]
    public class SequenceActiveStateEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.PoseDetection.Editor.Generated
{
    [CustomEditor(typeof(ShapeRecognizerActiveState), false, isFallback = true)]
    public class ShapeRecognizerActiveStateEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.PoseDetection.Editor.Generated
{
    [CustomEditor(typeof(TransformFeatureStateProvider), false, isFallback = true)]
    public class TransformFeatureStateProviderEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.PoseDetection.Editor.Generated
{
    [CustomEditor(typeof(TransformRecognizerActiveState), false, isFallback = true)]
    public class TransformRecognizerActiveStateEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.PoseDetection.Debug.Editor.Generated
{
    [CustomEditor(typeof(ActiveStateDebugTreeUI), false, isFallback = true)]
    public class ActiveStateDebugTreeUIEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.PoseDetection.Debug.Editor.Generated
{
    [CustomEditor(typeof(ActiveStateDebugVisual), false, isFallback = true)]
    public class ActiveStateDebugVisualEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.PoseDetection.Debug.Editor.Generated
{
    [CustomEditor(typeof(ActiveStateNodeUIHorizontal), false, isFallback = true)]
    public class ActiveStateNodeUIHorizontalEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.PoseDetection.Debug.Editor.Generated
{
    [CustomEditor(typeof(ActiveStateNodeUIVertical), false, isFallback = true)]
    public class ActiveStateNodeUIVerticalEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.PoseDetection.Debug.Editor.Generated
{
    [CustomEditor(typeof(FingerFeatureDebugVisual), false, isFallback = true)]
    public class FingerFeatureDebugVisualEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.PoseDetection.Debug.Editor.Generated
{
    [CustomEditor(typeof(FingerFeatureSkeletalDebugVisual), false, isFallback = true)]
    public class FingerFeatureSkeletalDebugVisualEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.PoseDetection.Debug.Editor.Generated
{
    [CustomEditor(typeof(HandShapeDebugVisual), false, isFallback = true)]
    public class HandShapeDebugVisualEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.PoseDetection.Debug.Editor.Generated
{
    [CustomEditor(typeof(HandShapeSkeletalDebugVisual), false, isFallback = true)]
    public class HandShapeSkeletalDebugVisualEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.PoseDetection.Debug.Editor.Generated
{
    [CustomEditor(typeof(JointRotationDebugVisual), false, isFallback = true)]
    public class JointRotationDebugVisualEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.PoseDetection.Debug.Editor.Generated
{
    [CustomEditor(typeof(JointVelocityDebugVisual), false, isFallback = true)]
    public class JointVelocityDebugVisualEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.PoseDetection.Debug.Editor.Generated
{
    [CustomEditor(typeof(TransformFeatureDebugVisual), false, isFallback = true)]
    public class TransformFeatureDebugVisualEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.PoseDetection.Debug.Editor.Generated
{
    [CustomEditor(typeof(TransformFeatureVectorDebugParentVisual), false, isFallback = true)]
    public class TransformFeatureVectorDebugParentVisualEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.PoseDetection.Debug.Editor.Generated
{
    [CustomEditor(typeof(TransformFeatureVectorDebugVisual), false, isFallback = true)]
    public class TransformFeatureVectorDebugVisualEditorFallback : SimplifiedEditor { }
}

namespace Oculus.Interaction.PoseDetection.Debug.Editor.Generated
{
    [CustomEditor(typeof(TransformRecognizerDebugVisual), false, isFallback = true)]
    public class TransformRecognizerDebugVisualEditorFallback : SimplifiedEditor { }
}
