diff --git a/ebos/ecloutputblackoilmodule.hh b/ebos/ecloutputblackoilmodule.hh
index 092dcc6eb..284848374 100644
--- a/ebos/ecloutputblackoilmodule.hh
+++ b/ebos/ecloutputblackoilmodule.hh
@@ -1278,7 +1278,7 @@ public:
                                 const auto ctlMode = controls.cmode;
                                 const auto injType = controls.injector_type;                            
                                 using CMode = ::Opm::Well::InjectorCMode;
-                                using WType = ::Opm::Well::InjectorType;
+                                using WType = ::Opm::InjectorType;
                                 
                                 auto ftype = [](const auto wtype) -> std::string
                                 {
@@ -1404,7 +1404,7 @@ public:
                                         const auto ctlMode = controls.cmode;
                                         const auto injType = controls.injector_type;                            
                                         using CMode = ::Opm::Well::InjectorCMode;
-                                        using WType = ::Opm::Well::InjectorType;
+                                        using WType = ::Opm::InjectorType;
                                         
                                         auto ftype = [](const auto wtype) -> std::string
                                         {
diff --git a/ebos/eclwellmanager.hh b/ebos/eclwellmanager.hh
index ba95dc276..cad65de54 100644
--- a/ebos/eclwellmanager.hh
+++ b/ebos/eclwellmanager.hh
@@ -185,16 +185,16 @@ public:
                 well->setWellType(Well::Injector);
                 const auto controls = deckWell.injectionControls(summaryState);
                 switch (controls.injector_type) {
-                case Opm::Well::InjectorType::WATER:
+                case Opm::InjectorType::WATER:
                     well->setInjectedPhaseIndex(FluidSystem::waterPhaseIdx);
                     break;
-                case Opm::Well::InjectorType::GAS:
+                case Opm::InjectorType::GAS:
                     well->setInjectedPhaseIndex(FluidSystem::gasPhaseIdx);
                     break;
-                case Opm::Well::InjectorType::OIL:
+                case Opm::InjectorType::OIL:
                     well->setInjectedPhaseIndex(FluidSystem::oilPhaseIdx);
                     break;
-                case Opm::Well::InjectorType::MULTI:
+                case Opm::InjectorType::MULTI:
                     throw std::runtime_error("Not implemented: Multi-phase injector wells");
                 }
 
@@ -226,19 +226,19 @@ public:
                 }
 
                 switch (controls.injector_type) {
-                case Opm::Well::InjectorType::WATER:
+                case Opm::InjectorType::WATER:
                     well->setVolumetricPhaseWeights(/*oil=*/0.0, /*gas=*/0.0, /*water=*/1.0);
                     break;
 
-                case Opm::Well::InjectorType::OIL:
+                case Opm::InjectorType::OIL:
                     well->setVolumetricPhaseWeights(/*oil=*/1.0, /*gas=*/0.0, /*water=*/0.0);
                     break;
 
-                case Opm::Well::InjectorType::GAS:
+                case Opm::InjectorType::GAS:
                     well->setVolumetricPhaseWeights(/*oil=*/0.0, /*gas=*/1.0, /*water=*/0.0);
                     break;
 
-                case Opm::Well::InjectorType::MULTI:
+                case Opm::InjectorType::MULTI:
                     throw std::runtime_error("Not implemented: Multi-phase injection wells");
                 }
 
diff --git a/opm/simulators/wells/MultisegmentWell.hpp b/opm/simulators/wells/MultisegmentWell.hpp
index 1caf962b1..6a1ad001b 100644
--- a/opm/simulators/wells/MultisegmentWell.hpp
+++ b/opm/simulators/wells/MultisegmentWell.hpp
@@ -382,7 +382,7 @@ namespace Opm
                                Opm::DeferredLogger& deferred_logger);
 
         void assembleGroupProductionControl(const Group& group, const WellState& well_state, const Opm::Schedule& schedule, const SummaryState& summaryState, EvalWell& control_eq, double efficincyFactor, Opm::DeferredLogger& deferred_logger);
-        void assembleGroupInjectionControl(const Group& group, const WellState& well_state, const Opm::Schedule& schedule, const SummaryState& summaryState,  const Well::InjectorType& injectorType, EvalWell& control_eq, double efficincyFactor, Opm::DeferredLogger& deferred_logger);
+        void assembleGroupInjectionControl(const Group& group, const WellState& well_state, const Opm::Schedule& schedule, const SummaryState& summaryState,  const InjectorType& injectorType, EvalWell& control_eq, double efficincyFactor, Opm::DeferredLogger& deferred_logger);
 
         void assemblePressureEq(const int seg) const;
 
diff --git a/opm/simulators/wells/MultisegmentWell_impl.hpp b/opm/simulators/wells/MultisegmentWell_impl.hpp
index 79fccfc23..2d7741719 100644
--- a/opm/simulators/wells/MultisegmentWell_impl.hpp
+++ b/opm/simulators/wells/MultisegmentWell_impl.hpp
@@ -301,20 +301,20 @@ namespace Opm
         {
             const auto& controls = well.injectionControls(summaryState);
 
-            Well::InjectorType injectorType = controls.injector_type;
+            InjectorType injectorType = controls.injector_type;
             int phasePos;
             switch (injectorType) {
-            case Well::InjectorType::WATER:
+            case InjectorType::WATER:
             {
                 phasePos = pu.phase_pos[BlackoilPhases::Aqua];
                 break;
             }
-            case Well::InjectorType::OIL:
+            case InjectorType::OIL:
             {
                 phasePos = pu.phase_pos[BlackoilPhases::Liquid];
                 break;
             }
-            case Well::InjectorType::GAS:
+            case InjectorType::GAS:
             {
                 phasePos = pu.phase_pos[BlackoilPhases::Vapour];
                 break;
@@ -891,7 +891,7 @@ namespace Opm
                     auto phase = well.getInjectionProperties().injectorType;
 
                     if (FluidSystem::phaseIsActive(FluidSystem::waterPhaseIdx)) {
-                        if (phase == Well::InjectorType::WATER) {
+                        if (phase == InjectorType::WATER) {
                             primary_variables_[seg][WFrac] = 1.0;
                         } else {
                             primary_variables_[seg][WFrac] = 0.0;
@@ -899,7 +899,7 @@ namespace Opm
                     }
 
                     if (FluidSystem::phaseIsActive(FluidSystem::gasPhaseIdx)) {
-                        if (phase == Well::InjectorType::GAS) {
+                        if (phase == InjectorType::GAS) {
                             primary_variables_[seg][GFrac] = 1.0;
                         } else {
                             primary_variables_[seg][GFrac] = 0.0;
@@ -1650,18 +1650,18 @@ namespace Opm
 
             if (FluidSystem::phaseIsActive(FluidSystem::waterPhaseIdx)
                     && Indices::canonicalToActiveComponentIndex(FluidSystem::waterCompIdx) == comp_idx
-                    && phase == Well::InjectorType::WATER)
+                    && phase == InjectorType::WATER)
                 return primary_variables_evaluation_[seg][GTotal] / scalingFactor(ebosCompIdxToFlowCompIdx(comp_idx));
 
 
             if (FluidSystem::phaseIsActive(FluidSystem::oilPhaseIdx)
                     && Indices::canonicalToActiveComponentIndex(FluidSystem::oilCompIdx) == comp_idx
-                    && phase == Well::InjectorType::OIL)
+                    && phase == InjectorType::OIL)
                 return primary_variables_evaluation_[seg][GTotal] / scalingFactor(ebosCompIdxToFlowCompIdx(comp_idx));
 
             if (FluidSystem::phaseIsActive(FluidSystem::gasPhaseIdx)
                     && Indices::canonicalToActiveComponentIndex(FluidSystem::gasCompIdx) == comp_idx
-                    && phase == Well::InjectorType::GAS)
+                    && phase == InjectorType::GAS)
                 return primary_variables_evaluation_[seg][GTotal] / scalingFactor(ebosCompIdxToFlowCompIdx(comp_idx));
 
             return 0.0;
@@ -1768,23 +1768,23 @@ namespace Opm
             const Opm::Well::InjectorCMode& current = well_state.currentInjectionControls()[well_index];
             const auto& controls = inj_controls;
 
-            Well::InjectorType injectorType = controls.injector_type;
+            InjectorType injectorType = controls.injector_type;
             double scaling = 1.0;
 
             const auto& pu = phaseUsage();
 
             switch (injectorType) {
-            case Well::InjectorType::WATER:
+            case InjectorType::WATER:
             {
                 scaling = scalingFactor(pu.phase_pos[BlackoilPhases::Aqua]);
                 break;
             }
-            case Well::InjectorType::OIL:
+            case InjectorType::OIL:
             {
                 scaling = scalingFactor(pu.phase_pos[BlackoilPhases::Liquid]);
                 break;
             }
-            case Well::InjectorType::GAS:
+            case InjectorType::GAS:
             {
                 scaling = scalingFactor(pu.phase_pos[BlackoilPhases::Vapour]);
                 break;
@@ -1808,17 +1808,17 @@ namespace Opm
                 double coeff = 1.0;
 
                 switch (injectorType) {
-                case Well::InjectorType::WATER:
+                case InjectorType::WATER:
                 {
                     coeff = convert_coeff[pu.phase_pos[BlackoilPhases::Aqua]];
                     break;
                 }
-                case Well::InjectorType::OIL:
+                case InjectorType::OIL:
                 {
                     coeff = convert_coeff[pu.phase_pos[BlackoilPhases::Liquid]];
                     break;
                 }
-                case Well::InjectorType::GAS:
+                case InjectorType::GAS:
                 {
                     coeff = convert_coeff[pu.phase_pos[BlackoilPhases::Vapour]];
                     break;
@@ -2113,7 +2113,7 @@ namespace Opm
     template <typename TypeTag>
     void
     MultisegmentWell<TypeTag>::
-    assembleGroupInjectionControl(const Group& group, const WellState& well_state, const Opm::Schedule& schedule, const SummaryState& summaryState, const Well::InjectorType& injectorType, EvalWell& control_eq, double efficiencyFactor, Opm::DeferredLogger& deferred_logger)
+    assembleGroupInjectionControl(const Group& group, const WellState& well_state, const Opm::Schedule& schedule, const SummaryState& summaryState, const InjectorType& injectorType, EvalWell& control_eq, double efficiencyFactor, Opm::DeferredLogger& deferred_logger)
     {
         const auto& well = well_ecl_;
         const auto& pu = phaseUsage();
@@ -2124,7 +2124,7 @@ namespace Opm
         double scaling = 1.0;
 
         switch (injectorType) {
-        case Well::InjectorType::WATER:
+        case InjectorType::WATER:
         {
             phasePos = pu.phase_pos[BlackoilPhases::Aqua];
             wellTarget = Well::GuideRateTarget::WAT;
@@ -2132,7 +2132,7 @@ namespace Opm
             scaling = scalingFactor(pu.phase_pos[BlackoilPhases::Aqua]);
             break;
         }
-        case Well::InjectorType::OIL:
+        case InjectorType::OIL:
         {
             phasePos = pu.phase_pos[BlackoilPhases::Liquid];
             wellTarget = Well::GuideRateTarget::OIL;
@@ -2140,7 +2140,7 @@ namespace Opm
             scaling = scalingFactor(pu.phase_pos[BlackoilPhases::Liquid]);
             break;
         }
-        case Well::InjectorType::GAS:
+        case InjectorType::GAS:
         {
             phasePos = pu.phase_pos[BlackoilPhases::Vapour];
             wellTarget = Well::GuideRateTarget::GAS;
diff --git a/opm/simulators/wells/StandardWell.hpp b/opm/simulators/wells/StandardWell.hpp
index 032abb3fa..69a8a9629 100644
--- a/opm/simulators/wells/StandardWell.hpp
+++ b/opm/simulators/wells/StandardWell.hpp
@@ -34,6 +34,7 @@
 #include <opm/models/blackoil/blackoilbrinemodules.hh>
 
 #include <opm/material/densead/DynamicEvaluation.hpp>
+#include <opm/parser/eclipse/EclipseState/Schedule/ScheduleTypes.hpp>
 
 #include <dune/common/dynvector.hh>
 #include <dune/common/dynmatrix.hh>
@@ -404,7 +405,7 @@ namespace Opm
         void assembleControlEq(const WellState& well_state, const Opm::Schedule& schedule, const SummaryState& summaryState, Opm::DeferredLogger& deferred_logger);
 
         void assembleGroupProductionControl(const Group& group, const WellState& well_state, const Opm::Schedule& schedule, const SummaryState& summaryState, EvalWell& control_eq, double efficincyFactor, Opm::DeferredLogger& deferred_logger);
-        void assembleGroupInjectionControl(const Group& group, const WellState& well_state, const Opm::Schedule& schedule, const SummaryState& summaryState,  const Well::InjectorType& injectorType, EvalWell& control_eq, double efficincyFactor, Opm::DeferredLogger& deferred_logger);
+        void assembleGroupInjectionControl(const Group& group, const WellState& well_state, const Opm::Schedule& schedule, const SummaryState& summaryState,  const InjectorType& injectorType, EvalWell& control_eq, double efficincyFactor, Opm::DeferredLogger& deferred_logger);
 
         // handle the non reasonable fractions due to numerical overshoot
         void processFractions() const;
diff --git a/opm/simulators/wells/StandardWell_impl.hpp b/opm/simulators/wells/StandardWell_impl.hpp
index c6b51919b..c9bfabd34 100644
--- a/opm/simulators/wells/StandardWell_impl.hpp
+++ b/opm/simulators/wells/StandardWell_impl.hpp
@@ -193,24 +193,24 @@ namespace Opm
         if (this->isInjector()) { // only single phase injection
             double inj_frac = 0.0;
             switch (this->wellEcl().injectorType()) {
-            case Well::InjectorType::WATER:
+            case InjectorType::WATER:
                 if (comp_idx == int(Indices::canonicalToActiveComponentIndex(FluidSystem::waterCompIdx))) {
                     inj_frac = 1.0;
                 }
                 break;
-            case Well::InjectorType::GAS:
+            case InjectorType::GAS:
                 if (has_solvent && comp_idx == contiSolventEqIdx) { // solvent
                     inj_frac = wsolvent();
                 } else if (comp_idx == int(Indices::canonicalToActiveComponentIndex(FluidSystem::gasCompIdx))) {
                     inj_frac = has_solvent ? 1.0 - wsolvent() : 1.0;
                 }
                 break;
-            case Well::InjectorType::OIL:
+            case InjectorType::OIL:
                 if (comp_idx == int(Indices::canonicalToActiveComponentIndex(FluidSystem::oilCompIdx))) {
                     inj_frac = 1.0;
                 }
                 break;
-            case Well::InjectorType::MULTI:
+            case InjectorType::MULTI:
                 // Not supported.
                 // deferred_logger.warning("MULTI_PHASE_INJECTOR_NOT_SUPPORTED",
                 //                         "Multi phase injectors are not supported, requested for well " + name());
@@ -643,7 +643,7 @@ namespace Opm
                     // change temperature for injecting fluids
                     if (this->isInjector() && cq_s[activeCompIdx] > 0.0){
                         // only handles single phase injection now
-                        assert(this->well_ecl_.injectorType() != Well::InjectorType::MULTI);
+                        assert(this->well_ecl_.injectorType() != InjectorType::MULTI);
                         fs.setTemperature(this->well_ecl_.temperature());
                         typedef typename std::decay<decltype(fs)>::type::Scalar FsScalar;
                         typename FluidSystem::template ParameterCache<FsScalar> paramCache;
@@ -791,21 +791,21 @@ namespace Opm
                 Base::rateConverter_.calcCoeff(/*fipreg*/ 0, Base::pvtRegionIdx_, convert_coeff);
                 const auto& pu = phaseUsage();
 
-                Well::InjectorType injectorType = controls.injector_type;
+                InjectorType injectorType = controls.injector_type;
                 double coeff = 1.0;
 
                 switch (injectorType) {
-                case Well::InjectorType::WATER:
+                case InjectorType::WATER:
                 {
                     coeff = convert_coeff[pu.phase_pos[BlackoilPhases::Aqua]];
                     break;
                 }
-                case Well::InjectorType::OIL:
+                case InjectorType::OIL:
                 {
                     coeff = convert_coeff[pu.phase_pos[BlackoilPhases::Liquid]];
                     break;
                 }
-                case Well::InjectorType::GAS:
+                case InjectorType::GAS:
                 {
                     coeff = convert_coeff[pu.phase_pos[BlackoilPhases::Vapour]];
                     break;
@@ -979,7 +979,7 @@ namespace Opm
     template <typename TypeTag>
     void
     StandardWell<TypeTag>::
-    assembleGroupInjectionControl(const Group& group, const WellState& well_state, const Opm::Schedule& schedule, const SummaryState& summaryState, const Well::InjectorType& injectorType, EvalWell& control_eq, double efficiencyFactor, Opm::DeferredLogger& deferred_logger)
+    assembleGroupInjectionControl(const Group& group, const WellState& well_state, const Opm::Schedule& schedule, const SummaryState& summaryState, const InjectorType& injectorType, EvalWell& control_eq, double efficiencyFactor, Opm::DeferredLogger& deferred_logger)
     {
         const auto& well = well_ecl_;
         const auto pu = phaseUsage();
@@ -989,21 +989,21 @@ namespace Opm
         Phase injectionPhase;
 
         switch (injectorType) {
-        case Well::InjectorType::WATER:
+        case InjectorType::WATER:
         {
             phasePos = pu.phase_pos[BlackoilPhases::Aqua];
             wellTarget = Well::GuideRateTarget::WAT;
             injectionPhase = Phase::WATER;
             break;
         }
-        case Well::InjectorType::OIL:
+        case InjectorType::OIL:
         {
             phasePos = pu.phase_pos[BlackoilPhases::Liquid];
             wellTarget = Well::GuideRateTarget::OIL;
             injectionPhase = Phase::OIL;
             break;
         }
-        case Well::InjectorType::GAS:
+        case InjectorType::GAS:
         {
             phasePos = pu.phase_pos[BlackoilPhases::Vapour];
             wellTarget = Well::GuideRateTarget::GAS;
@@ -1587,16 +1587,16 @@ namespace Opm
                 well_state.wellRates()[index_of_well_ * number_of_phases_ + p] = 0.0;
             }
             switch (this->wellEcl().injectorType()) {
-            case Well::InjectorType::WATER:
+            case InjectorType::WATER:
                 well_state.wellRates()[index_of_well_ * number_of_phases_ + pu.phase_pos[Water]] = primary_variables_[WQTotal];
                 break;
-            case Well::InjectorType::GAS:
+            case InjectorType::GAS:
                 well_state.wellRates()[index_of_well_ * number_of_phases_ + pu.phase_pos[Gas]] = primary_variables_[WQTotal];
                 break;
-            case Well::InjectorType::OIL:
+            case InjectorType::OIL:
                 well_state.wellRates()[index_of_well_ * number_of_phases_ + pu.phase_pos[Oil]] = primary_variables_[WQTotal];
                 break;
-            case Well::InjectorType::MULTI:
+            case InjectorType::MULTI:
                 // Not supported.
                 deferred_logger.warning("MULTI_PHASE_INJECTOR_NOT_SUPPORTED",
                                         "Multi phase injectors are not supported, requested for well " + name());
@@ -1681,20 +1681,20 @@ namespace Opm
         {
             const auto& controls = well.injectionControls(summaryState);
 
-            Well::InjectorType injectorType = controls.injector_type;
+            InjectorType injectorType = controls.injector_type;
             int phasePos;
             switch (injectorType) {
-            case Well::InjectorType::WATER:
+            case InjectorType::WATER:
             {
                 phasePos = pu.phase_pos[BlackoilPhases::Aqua];
                 break;
             }
-            case Well::InjectorType::OIL:
+            case InjectorType::OIL:
             {
                 phasePos = pu.phase_pos[BlackoilPhases::Liquid];
                 break;
             }
-            case Well::InjectorType::GAS:
+            case InjectorType::GAS:
             {
                 phasePos = pu.phase_pos[BlackoilPhases::Vapour];
                 break;
@@ -2409,16 +2409,16 @@ namespace Opm
                 // No flow => use well specified fractions for mix.
                 if (this->isInjector()) {
                     switch (this->wellEcl().injectorType()) {
-                    case Well::InjectorType::WATER:
+                    case InjectorType::WATER:
                         mix[FluidSystem::waterCompIdx] = 1.0;
                         break;
-                    case Well::InjectorType::GAS:
+                    case InjectorType::GAS:
                         mix[FluidSystem::gasCompIdx] = 1.0;
                         break;
-                    case Well::InjectorType::OIL:
+                    case InjectorType::OIL:
                         mix[FluidSystem::oilCompIdx] = 1.0;
                         break;
-                    case Well::InjectorType::MULTI:
+                    case InjectorType::MULTI:
                         // Not supported.
                         // deferred_logger.warning("MULTI_PHASE_INJECTOR_NOT_SUPPORTED",
                         //                         "Multi phase injectors are not supported, requested for well " + name());
@@ -2968,16 +2968,16 @@ namespace Opm
         // under surface condition is used here
         if (this->isInjector()) {
             switch (this->wellEcl().injectorType()) {
-            case Well::InjectorType::WATER:
+            case InjectorType::WATER:
                 primary_variables_[WQTotal] = well_state.wellRates()[np * well_index + pu.phase_pos[Water]];
                 break;
-            case Well::InjectorType::GAS:
+            case InjectorType::GAS:
                 primary_variables_[WQTotal] = well_state.wellRates()[np * well_index + pu.phase_pos[Gas]];
                 break;
-            case Well::InjectorType::OIL:
+            case InjectorType::OIL:
                 primary_variables_[WQTotal] = well_state.wellRates()[np * well_index + pu.phase_pos[Oil]];
                 break;
-            case Well::InjectorType::MULTI:
+            case InjectorType::MULTI:
                 // Not supported.
                 deferred_logger.warning("MULTI_PHASE_INJECTOR_NOT_SUPPORTED",
                                         "Multi phase injectors are not supported, requested for well " + name());
@@ -3004,7 +3004,7 @@ namespace Opm
                 auto phase = well_ecl_.getInjectionProperties().injectorType;
                 // only single phase injection handled
                 if (FluidSystem::phaseIsActive(FluidSystem::waterPhaseIdx)) {
-                    if (phase == Well::InjectorType::WATER) {
+                    if (phase == InjectorType::WATER) {
                         primary_variables_[WFrac] = 1.0;
                     } else {
                         primary_variables_[WFrac] = 0.0;
@@ -3012,7 +3012,7 @@ namespace Opm
                 }
 
                 if (FluidSystem::phaseIsActive(FluidSystem::gasPhaseIdx)) {
-                    if (phase == Well::InjectorType::GAS) {
+                    if (phase == InjectorType::GAS) {
                         primary_variables_[GFrac] = 1.0 - wsolvent();
                         if (has_solvent) {
                             primary_variables_[SFrac] = wsolvent();
diff --git a/opm/simulators/wells/WellGroupHelpers.hpp b/opm/simulators/wells/WellGroupHelpers.hpp
index 28f31429b..742394b81 100644
--- a/opm/simulators/wells/WellGroupHelpers.hpp
+++ b/opm/simulators/wells/WellGroupHelpers.hpp
@@ -22,6 +22,7 @@
 #define OPM_WELLGROUPHELPERS_HEADER_INCLUDED
 
 #include <vector>
+#include <opm/parser/eclipse/EclipseState/Schedule/ScheduleTypes.hpp>
 
 namespace Opm {
 
@@ -66,18 +67,18 @@ namespace Opm {
             if (wellEcl.isInjector() && injector) {
                 // only switch if the well phase is the same as the group phase
                 // Get the current controls.
-                const Well::InjectorType& injectorType = wellEcl.getInjectionProperties().injectorType;
+                const InjectorType& injectorType = wellEcl.getInjectionProperties().injectorType;
 
-                if (injectorType == Well::InjectorType::WATER && groupInjectionPhase != Phase::WATER)
+                if (injectorType == InjectorType::WATER && groupInjectionPhase != Phase::WATER)
                     continue;
 
-                if (injectorType == Well::InjectorType::OIL && groupInjectionPhase != Phase::OIL)
+                if (injectorType == InjectorType::OIL && groupInjectionPhase != Phase::OIL)
                     continue;
 
-                if (injectorType == Well::InjectorType::GAS && groupInjectionPhase != Phase::GAS)
+                if (injectorType == InjectorType::GAS && groupInjectionPhase != Phase::GAS)
                     continue;
 
-                if (injectorType == Well::InjectorType::MULTI)
+                if (injectorType == InjectorType::MULTI)
                     throw("Expected WATER, OIL or GAS as type for injectors " + wellEcl.name());
 
                 if (wellState.currentInjectionControls()[well_index] != Well::InjectorCMode::GRUP) {
diff --git a/opm/simulators/wells/WellInterface_impl.hpp b/opm/simulators/wells/WellInterface_impl.hpp
index 857930470..b18549493 100644
--- a/opm/simulators/wells/WellInterface_impl.hpp
+++ b/opm/simulators/wells/WellInterface_impl.hpp
@@ -19,6 +19,7 @@
   along with OPM.  If not, see <http://www.gnu.org/licenses/>.
 */
 
+#include <opm/parser/eclipse/EclipseState/Schedule/ScheduleTypes.hpp>
 #include <opm/simulators/utils/DeferredLoggingErrorHelpers.hpp>
 
 namespace Opm
@@ -99,7 +100,7 @@ namespace Opm
 
         if (has_solvent && well.isInjector()) {
             auto injectorType = well_ecl_.injectorType();
-            if (injectorType == Well::InjectorType::GAS) {
+            if (injectorType == InjectorType::GAS) {
                 wsolvent_ = well_ecl_.getSolventFraction();
             }
         }
@@ -337,7 +338,7 @@ namespace Opm
 
         auto injectorType = well_ecl_.injectorType();
 
-        if (injectorType == Well::InjectorType::WATER) {
+        if (injectorType == InjectorType::WATER) {
             WellPolymerProperties polymer = well_ecl_.getPolymerProperties();
             const double polymer_injection_concentration = polymer.m_polymerConcentration;
             return polymer_injection_concentration;
@@ -362,7 +363,7 @@ namespace Opm
 
         auto injectorType = well_ecl_.injectorType();
 
-        if (injectorType == Well::InjectorType::GAS) {
+        if (injectorType == InjectorType::GAS) {
             WellFoamProperties fprop = well_ecl_.getFoamProperties();
             return fprop.m_foamConcentration;
         } else {
@@ -384,7 +385,7 @@ namespace Opm
 
         auto injectorType = well_ecl_.injectorType();
 
-        if (injectorType == Well::InjectorType::WATER) {
+        if (injectorType == InjectorType::WATER) {
             WellBrineProperties fprop = well_ecl_.getBrineProperties();
             return fprop.m_saltConcentration;
         } else {
@@ -1466,21 +1467,21 @@ namespace Opm
 
             if (controls.hasControl(Well::InjectorCMode::RATE) && currentControl != Well::InjectorCMode::RATE)
             {
-                Well::InjectorType injectorType = controls.injector_type;
+                InjectorType injectorType = controls.injector_type;
                 double current_rate = 0.0;
 
                 switch (injectorType) {
-                case Well::InjectorType::WATER:
+                case InjectorType::WATER:
                 {
                     current_rate = well_state.wellRates()[ wellrate_index + pu.phase_pos[BlackoilPhases::Aqua] ];
                     break;
                 }
-                case Well::InjectorType::OIL:
+                case InjectorType::OIL:
                 {
                     current_rate = well_state.wellRates()[ wellrate_index + pu.phase_pos[BlackoilPhases::Liquid] ];
                     break;
                 }
-                case Well::InjectorType::GAS:
+                case InjectorType::GAS:
                 {
                     current_rate = well_state.wellRates()[ wellrate_index + pu.phase_pos[BlackoilPhases::Vapour] ];
                     break;
diff --git a/opm/simulators/wells/WellState.hpp b/opm/simulators/wells/WellState.hpp
index de5a3d7ed..cd5155923 100644
--- a/opm/simulators/wells/WellState.hpp
+++ b/opm/simulators/wells/WellState.hpp
@@ -296,19 +296,19 @@ namespace Opm
                 if (well.isInjector()) {
                     if (inj_controls.cmode == Well::InjectorCMode::RATE) {
                         switch (inj_controls.injector_type) {
-                        case Well::InjectorType::WATER:
+                        case InjectorType::WATER:
                             assert(pu.phase_used[BlackoilPhases::Aqua]);
                             wellrates_[np*w + pu.phase_pos[BlackoilPhases::Aqua]] = inj_surf_rate;
                             break;
-                        case Well::InjectorType::GAS:
+                        case InjectorType::GAS:
                             assert(pu.phase_used[BlackoilPhases::Vapour]);
                             wellrates_[np*w + pu.phase_pos[BlackoilPhases::Vapour]] = inj_surf_rate;
                             break;
-                        case Well::InjectorType::OIL:
+                        case InjectorType::OIL:
                             assert(pu.phase_used[BlackoilPhases::Liquid]);
                             wellrates_[np*w + pu.phase_pos[BlackoilPhases::Liquid]] = inj_surf_rate;
                             break;
-                        case Well::InjectorType::MULTI:
+                        case InjectorType::MULTI:
                             // Not currently handled, keep zero init.
                             break;
                         }
diff --git a/tests/test_ParallelRestart.cpp b/tests/test_ParallelRestart.cpp
index 882bea779..6f0ff828c 100644
--- a/tests/test_ParallelRestart.cpp
+++ b/tests/test_ParallelRestart.cpp
@@ -1590,7 +1590,7 @@ BOOST_AUTO_TEST_CASE(WellInjectionProperties)
                                             7,
                                             true,
                                             8,
-                                            Opm::Well::InjectorType::OIL,
+                                            Opm::InjectorType::OIL,
                                             Opm::Well::InjectorCMode::BHP);
     auto val2 = PackUnpack(val1);
     DO_CHECKS(Well::WellInjectionProperties)