1. Inconsistent accessibility: parameter type 'WaveGesture.MainWindow.WaveGestureState' is less accessible than method 'WaveGesture.MainWindow.UpdateState (WaveGesture.MainWindow.WaveGestureState, long)'

2. Inconsistent accessibility: parameter type 'WaveGesture.MainWindow.WavePosition' is less accessible than method 'WaveGesture.MainWindow.UpdatePosition (WaveGesture.MainWindow.WavePosition, long)'

If I change those enumerations to public, I get so many errors. Can anyone please tell me whats wrong?

The code:

private enum WavePosition
        {
            None = 0,
            Left = 1,
            Right = 2,
            Neutral = 3
        }

        private enum WaveGestureState
        {
            None = 0,
            Success = 1,
            Failure = 2,
            InProgress = 3
        }

        private struct WaveGestureTracker
        {
            public void Reset()
            {
                IterationCount = 0;
                State = GestureState.None;
                Timestamp = 0;
                StartPosition = WavePosition.None;
                CurrentPosition = WavePosition.None;
            }

            public int IterationCount;
            public WaveGestureState State;
            public long Timestamp;
        }

        public class WaveGesture
        {
            private const float WAVE_THRESHOLD = 0.1f;
            private const int WAVE_MOVEMENT_TIMEOUT = 5000;
            private const int REQUIRED_ITERATIONS = 4;
            private WaveGestureTracker[,] _PlayerWaveTracker = new WaveGestureTracker[6, 2];
            public event EventHandler GestureDetected;

            public void Update(Skeleton[] skeletons, long frameTimestamp)
            {
                if (skeletons != null)
                {
                    Skeleton skeleton;
                    for (int i = 0; i < skeletons.Length; i++)
                    {
                        skeleton = skeletons[i];
                        if (skeleton.TrackingState != SkeletonTrackingState.NotTracked)
                        {
                            TrackWave(skeleton, true,
                            ref this._PlayerWaveTracker[i, LEFT_HAND], frameTimestamp);
                            TrackWave(skeleton, false,
                            ref this._PlayerWaveTracker[i, RIGHT_HAND], frameTimestamp);
                        }
                        else
                        {
                            this._PlayerWaveTracker[i, LEFT_HAND].Reset();
                            this._PlayerWaveTracker[i, RIGHT_HAND].Reset();
                        }
                    }
                }
            }

        }

        private void TrackWave(Skeleton skeleton, bool isLeft, ref WaveGestureTracker tracker, long timestamp)
        {
            JointType handJointId = (isLeft) ? JointType.HandLeft : JointType.HandRight;
            JointType elbowJointId = (isLeft) ? JointType.ElbowLeft : JointType.ElbowRight;
            Joint hand = skeleton.Joints[handJointId];
            Joint elbow = skeleton.Joints[elbowJointId];

            if (hand.TrackingState != JointTrackingState.NotTracked && elbow.TrackingState != JointTrackingState.NotTracked)
            {
                if (tracker.State == WaveGestureState.InProgress && tracker.Timestamp + WAVE_MOVEMENT_TIMEOUT < timestamp)
                {
                    tracker.UpdateState(WaveGestureState.Failure, timestamp);
                }
                else if (hand.Position.Y > elbow.Position.Y)
                {
                    //Using the raw values where (0, 0) is the middle of the screen.
                    //From the user's perspective, the X-Axis grows more negative left
                    //and more positive right.
                    if (hand.Position.X <= elbow.Position.X - WAVE_THRESHOLD)
                    {
                        tracker.UpdatePosition(WavePosition.Left, timestamp);
                    }
                    else if (hand.Position.X >= elbow.Position.X + WAVE_THRESHOLD)
                    {
                        tracker.UpdatePosition(WavePosition.Right, timestamp);
                    }
                    else
                    {
                        tracker.UpdatePosition(WavePosition.Neutral, timestamp);
                    }

                    if (tracker.State != WaveGestureState.Success && tracker.IterationCount == REQUIRED_ITERATIONS)
                    {
                        tracker.UpdateState(WaveGestureState.Success, timestamp);

                        if (GestureDetected != null)
                        {
                            GestureDetected(this, new EventArgs());
                        }
                    }
                }
                else
                {
                    if (tracker.State == WaveGestureState.InProgress)
                    {
                        tracker.UpdateState(WaveGestureState.Failure, timestamp);
                    }
                    else
                    {
                        tracker.Reset();
                    }
                }
            }
            else
            {
                tracker.Reset();
            }
        }

        public void UpdateState(WaveGestureState state, long timestamp)
        {
            state = State;
            timestamp = Timestamp;
        }

        public void Reset()
        {
            IterationCount = 0;
            State = WaveGestureState.None;
            Timestamp = 0;
            StartPosition = WavePosition.None;
            CurrentPosition = WavePosition.None;
        }

        public void UpdatePosition(WavePosition position, long timestamp)
        {

            if (CurrentPosition != position)
            {
                if (position == WavePosition.Left || position == WavePosition.Right)
                {
                    if (State != WaveGestureState.InProgress)
                    {
                        State = WaveGestureState.InProgress;
                        IterationCount = 0;
                        StartPosition = position;
                    }

                    IterationCount++;
                }

                position = CurrentPosition;
                timestamp = Timestamp;
            }
        }