ObjectFactory.java

package sk.iway.iwcm.components.weather.met.no.generated;

import javax.xml.bind.JAXBElement;
import javax.xml.bind.annotation.XmlElementDecl;
import javax.xml.bind.annotation.XmlRegistry;
import javax.xml.namespace.QName;


/**
 * This object contains factory methods for each 
 * Java content interface and Java element interface 
 * generated in the generated package. 
 * <p>An ObjectFactory allows you to programatically 
 * construct new instances of the Java representation 
 * for XML content. The Java representation of XML 
 * content can consist of schema derived interfaces 
 * and classes representing the binding of schema 
 * type definitions, element declarations and model 
 * groups.  Factory methods for each of these are 
 * provided in this class.
 * 
 */
@XmlRegistry
public class ObjectFactory {

    private final static QName _LocationTypeMaxTemperature_QNAME = new QName("", "maxTemperature");
    private final static QName _LocationTypeSymbol_QNAME = new QName("", "symbol");
    private final static QName _LocationTypeHighestTemperature_QNAME = new QName("", "highestTemperature");
    private final static QName _LocationTypeWindGust_QNAME = new QName("", "windGust");
    private final static QName _LocationTypeCurrentDirection_QNAME = new QName("", "currentDirection");
    private final static QName _LocationTypeStateOfTheSea_QNAME = new QName("", "stateOfTheSea");
    private final static QName _LocationTypeMeanabsoluteerror_QNAME = new QName("", "meanabsoluteerror");
    private final static QName _LocationTypeMaximumPrecipitation_QNAME = new QName("", "maximumPrecipitation");
    private final static QName _LocationTypeTidalwater_QNAME = new QName("", "tidalwater");
    private final static QName _LocationTypeWaveHeight_QNAME = new QName("", "waveHeight");
    private final static QName _LocationTypePrecipitation_QNAME = new QName("", "precipitation");
    private final static QName _LocationTypeScore_QNAME = new QName("", "score");
    private final static QName _LocationTypeAreaMaxWindSpeed_QNAME = new QName("", "areaMaxWindSpeed");
    private final static QName _LocationTypeSnowDepth_QNAME = new QName("", "snowDepth");
    private final static QName _LocationTypeLowClouds_QNAME = new QName("", "lowClouds");
    private final static QName _LocationTypeMinTemperature_QNAME = new QName("", "minTemperature");
    private final static QName _LocationTypeBias_QNAME = new QName("", "bias");
    private final static QName _LocationTypeTemperature_QNAME = new QName("", "temperature");
    private final static QName _LocationTypeWeather_QNAME = new QName("", "weather");
    private final static QName _LocationTypeHumidity_QNAME = new QName("", "humidity");
    private final static QName _LocationTypeNumberofobservations_QNAME = new QName("", "numberofobservations");
    private final static QName _LocationTypeWindDirection_QNAME = new QName("", "windDirection");
    private final static QName _LocationTypeMaxTemperatureDay_QNAME = new QName("", "maxTemperatureDay");
    private final static QName _LocationTypeWindSpeed_QNAME = new QName("", "windSpeed");
    private final static QName _LocationTypeWavePeriod_QNAME = new QName("", "wavePeriod");
    private final static QName _LocationTypeMinTemperatureNight_QNAME = new QName("", "minTemperatureNight");
    private final static QName _LocationTypeUv_QNAME = new QName("", "uv");
    private final static QName _LocationTypeHighClouds_QNAME = new QName("", "highClouds");
    private final static QName _LocationTypeMaxTemperatureNight_QNAME = new QName("", "maxTemperatureNight");
    private final static QName _LocationTypeWindProbability_QNAME = new QName("", "windProbability");
    private final static QName _LocationTypeMaxWaveHeight_QNAME = new QName("", "maxWaveHeight");
    private final static QName _LocationTypeSurfaceTemperature_QNAME = new QName("", "surfaceTemperature");
    private final static QName _LocationTypePressure_QNAME = new QName("", "pressure");
    private final static QName _LocationTypeCloudiness_QNAME = new QName("", "cloudiness");
    private final static QName _LocationTypeWaveDirection_QNAME = new QName("", "waveDirection");
    private final static QName _LocationTypeSymbolProbability_QNAME = new QName("", "symbolProbability");
    private final static QName _LocationTypeTemperatureProbability_QNAME = new QName("", "temperatureProbability");
    private final static QName _LocationTypeGroundCover_QNAME = new QName("", "groundCover");
    private final static QName _LocationTypeMinTemperatureDay_QNAME = new QName("", "minTemperatureDay");
    private final static QName _LocationTypeMaxWindSpeed_QNAME = new QName("", "maxWindSpeed");
    private final static QName _LocationTypeForestFire_QNAME = new QName("", "forest-fire");
    private final static QName _LocationTypeMediumClouds_QNAME = new QName("", "mediumClouds");
    private final static QName _LocationTypeDewpointTemperature_QNAME = new QName("", "dewpointTemperature");
    private final static QName _LocationTypeLowestTemperature_QNAME = new QName("", "lowestTemperature");
    private final static QName _LocationTypeFog_QNAME = new QName("", "fog");

    /**
     * Create a new ObjectFactory that can be used to create new instances of schema derived classes for package: generated
     * 
     */
    public ObjectFactory() {
    }

    /**
     * Create an instance of {@link LocationType }
     * 
     */
    public LocationType createLocationType() {
        return new LocationType();
    }

    /**
     * Create an instance of {@link Weatherdata }
     * 
     */
    public Weatherdata createWeatherdata() {
        return new Weatherdata();
    }

    /**
     * Create an instance of {@link MetaType }
     * 
     */
    public MetaType createMetaType() {
        return new MetaType();
    }

    /**
     * Create an instance of {@link ProductType }
     * 
     */
    public ProductType createProductType() {
        return new ProductType();
    }

    /**
     * Create an instance of {@link Uv }
     * 
     */
    public Uv createUv() {
        return new Uv();
    }

    /**
     * Create an instance of {@link TimeType }
     * 
     */
    public TimeType createTimeType() {
        return new TimeType();
    }

    /**
     * Create an instance of {@link ModelType }
     * 
     */
    public ModelType createModelType() {
        return new ModelType();
    }

    /**
     * Create an instance of {@link Cloudiness }
     * 
     */
    public Cloudiness createCloudiness() {
        return new Cloudiness();
    }

    /**
     * Create an instance of {@link Pressure }
     * 
     */
    public Pressure createPressure() {
        return new Pressure();
    }

    /**
     * Create an instance of {@link Tidalwater }
     * 
     */
    public Tidalwater createTidalwater() {
        return new Tidalwater();
    }

    /**
     * Create an instance of {@link Precipitation }
     * 
     */
    public Precipitation createPrecipitation() {
        return new Precipitation();
    }

    /**
     * Create an instance of {@link Score }
     * 
     */
    public Score createScore() {
        return new Score();
    }

    /**
     * Create an instance of {@link Groundcover }
     * 
     */
    public Groundcover createGroundcover() {
        return new Groundcover();
    }

    /**
     * Create an instance of {@link Temperature }
     * 
     */
    public Temperature createTemperature() {
        return new Temperature();
    }

    /**
     * Create an instance of {@link Windspeed }
     * 
     */
    public Windspeed createWindspeed() {
        return new Windspeed();
    }

    /**
     * Create an instance of {@link UnitValue }
     * 
     */
    public UnitValue createUnitValue() {
        return new UnitValue();
    }

    /**
     * Create an instance of {@link LocationType.WindDirection }
     * 
     */
    public LocationType.WindDirection createLocationTypeWindDirection() {
        return new LocationType.WindDirection();
    }

    /**
     * Create an instance of {@link LocationType.StateOfTheSea }
     * 
     */
    public LocationType.StateOfTheSea createLocationTypeStateOfTheSea() {
        return new LocationType.StateOfTheSea();
    }

    /**
     * Create an instance of {@link LocationType.SnowDepth }
     * 
     */
    public LocationType.SnowDepth createLocationTypeSnowDepth() {
        return new LocationType.SnowDepth();
    }

    /**
     * Create an instance of {@link LocationType.Weather }
     * 
     */
    public LocationType.Weather createLocationTypeWeather() {
        return new LocationType.Weather();
    }

    /**
     * Create an instance of {@link LocationType.Symbol }
     * 
     */
    public LocationType.Symbol createLocationTypeSymbol() {
        return new LocationType.Symbol();
    }

    /**
     * Create an instance of {@link LocationType.ForestFire }
     * 
     */
    public LocationType.ForestFire createLocationTypeForestFire() {
        return new LocationType.ForestFire();
    }

    /**
     * Create an instance of {@link JAXBElement }{@code <}{@link Temperature }{@code >}}
     * 
     */
    @XmlElementDecl(namespace = "", name = "maxTemperature", scope = LocationType.class)
    public JAXBElement<Temperature> createLocationTypeMaxTemperature(Temperature value) {
        return new JAXBElement<Temperature>(_LocationTypeMaxTemperature_QNAME, Temperature.class, LocationType.class, value);
    }

    /**
     * Create an instance of {@link JAXBElement }{@code <}{@link LocationType.Symbol }{@code >}}
     * 
     */
    @XmlElementDecl(namespace = "", name = "symbol", scope = LocationType.class)
    public JAXBElement<LocationType.Symbol> createLocationTypeSymbol(LocationType.Symbol value) {
        return new JAXBElement<LocationType.Symbol>(_LocationTypeSymbol_QNAME, LocationType.Symbol.class, LocationType.class, value);
    }

    /**
     * Create an instance of {@link JAXBElement }{@code <}{@link Temperature }{@code >}}
     * 
     */
    @XmlElementDecl(namespace = "", name = "highestTemperature", scope = LocationType.class)
    public JAXBElement<Temperature> createLocationTypeHighestTemperature(Temperature value) {
        return new JAXBElement<Temperature>(_LocationTypeHighestTemperature_QNAME, Temperature.class, LocationType.class, value);
    }

    /**
     * Create an instance of {@link JAXBElement }{@code <}{@link Windspeed }{@code >}}
     * 
     */
    @XmlElementDecl(namespace = "", name = "windGust", scope = LocationType.class)
    public JAXBElement<Windspeed> createLocationTypeWindGust(Windspeed value) {
        return new JAXBElement<Windspeed>(_LocationTypeWindGust_QNAME, Windspeed.class, LocationType.class, value);
    }

    /**
     * Create an instance of {@link JAXBElement }{@code <}{@link UnitValue }{@code >}}
     * 
     */
    @XmlElementDecl(namespace = "", name = "currentDirection", scope = LocationType.class)
    public JAXBElement<UnitValue> createLocationTypeCurrentDirection(UnitValue value) {
        return new JAXBElement<UnitValue>(_LocationTypeCurrentDirection_QNAME, UnitValue.class, LocationType.class, value);
    }

    /**
     * Create an instance of {@link JAXBElement }{@code <}{@link LocationType.StateOfTheSea }{@code >}}
     * 
     */
    @XmlElementDecl(namespace = "", name = "stateOfTheSea", scope = LocationType.class)
    public JAXBElement<LocationType.StateOfTheSea> createLocationTypeStateOfTheSea(LocationType.StateOfTheSea value) {
        return new JAXBElement<LocationType.StateOfTheSea>(_LocationTypeStateOfTheSea_QNAME, LocationType.StateOfTheSea.class, LocationType.class, value);
    }

    /**
     * Create an instance of {@link JAXBElement }{@code <}{@link UnitValue }{@code >}}
     * 
     */
    @XmlElementDecl(namespace = "", name = "meanabsoluteerror", scope = LocationType.class)
    public JAXBElement<UnitValue> createLocationTypeMeanabsoluteerror(UnitValue value) {
        return new JAXBElement<UnitValue>(_LocationTypeMeanabsoluteerror_QNAME, UnitValue.class, LocationType.class, value);
    }

    /**
     * Create an instance of {@link JAXBElement }{@code <}{@link Precipitation }{@code >}}
     * 
     */
    @XmlElementDecl(namespace = "", name = "maximumPrecipitation", scope = LocationType.class)
    public JAXBElement<Precipitation> createLocationTypeMaximumPrecipitation(Precipitation value) {
        return new JAXBElement<Precipitation>(_LocationTypeMaximumPrecipitation_QNAME, Precipitation.class, LocationType.class, value);
    }

    /**
     * Create an instance of {@link JAXBElement }{@code <}{@link Tidalwater }{@code >}}
     * 
     */
    @XmlElementDecl(namespace = "", name = "tidalwater", scope = LocationType.class)
    public JAXBElement<Tidalwater> createLocationTypeTidalwater(Tidalwater value) {
        return new JAXBElement<Tidalwater>(_LocationTypeTidalwater_QNAME, Tidalwater.class, LocationType.class, value);
    }

    /**
     * Create an instance of {@link JAXBElement }{@code <}{@link UnitValue }{@code >}}
     * 
     */
    @XmlElementDecl(namespace = "", name = "waveHeight", scope = LocationType.class)
    public JAXBElement<UnitValue> createLocationTypeWaveHeight(UnitValue value) {
        return new JAXBElement<UnitValue>(_LocationTypeWaveHeight_QNAME, UnitValue.class, LocationType.class, value);
    }

    /**
     * Create an instance of {@link JAXBElement }{@code <}{@link Precipitation }{@code >}}
     * 
     */
    @XmlElementDecl(namespace = "", name = "precipitation", scope = LocationType.class)
    public JAXBElement<Precipitation> createLocationTypePrecipitation(Precipitation value) {
        return new JAXBElement<Precipitation>(_LocationTypePrecipitation_QNAME, Precipitation.class, LocationType.class, value);
    }

    /**
     * Create an instance of {@link JAXBElement }{@code <}{@link Score }{@code >}}
     * 
     */
    @XmlElementDecl(namespace = "", name = "score", scope = LocationType.class)
    public JAXBElement<Score> createLocationTypeScore(Score value) {
        return new JAXBElement<Score>(_LocationTypeScore_QNAME, Score.class, LocationType.class, value);
    }

    /**
     * Create an instance of {@link JAXBElement }{@code <}{@link Windspeed }{@code >}}
     * 
     */
    @XmlElementDecl(namespace = "", name = "areaMaxWindSpeed", scope = LocationType.class)
    public JAXBElement<Windspeed> createLocationTypeAreaMaxWindSpeed(Windspeed value) {
        return new JAXBElement<Windspeed>(_LocationTypeAreaMaxWindSpeed_QNAME, Windspeed.class, LocationType.class, value);
    }

    /**
     * Create an instance of {@link JAXBElement }{@code <}{@link LocationType.SnowDepth }{@code >}}
     * 
     */
    @XmlElementDecl(namespace = "", name = "snowDepth", scope = LocationType.class)
    public JAXBElement<LocationType.SnowDepth> createLocationTypeSnowDepth(LocationType.SnowDepth value) {
        return new JAXBElement<LocationType.SnowDepth>(_LocationTypeSnowDepth_QNAME, LocationType.SnowDepth.class, LocationType.class, value);
    }

    /**
     * Create an instance of {@link JAXBElement }{@code <}{@link Cloudiness }{@code >}}
     * 
     */
    @XmlElementDecl(namespace = "", name = "lowClouds", scope = LocationType.class)
    public JAXBElement<Cloudiness> createLocationTypeLowClouds(Cloudiness value) {
        return new JAXBElement<Cloudiness>(_LocationTypeLowClouds_QNAME, Cloudiness.class, LocationType.class, value);
    }

    /**
     * Create an instance of {@link JAXBElement }{@code <}{@link Temperature }{@code >}}
     * 
     */
    @XmlElementDecl(namespace = "", name = "minTemperature", scope = LocationType.class)
    public JAXBElement<Temperature> createLocationTypeMinTemperature(Temperature value) {
        return new JAXBElement<Temperature>(_LocationTypeMinTemperature_QNAME, Temperature.class, LocationType.class, value);
    }

    /**
     * Create an instance of {@link JAXBElement }{@code <}{@link UnitValue }{@code >}}
     * 
     */
    @XmlElementDecl(namespace = "", name = "bias", scope = LocationType.class)
    public JAXBElement<UnitValue> createLocationTypeBias(UnitValue value) {
        return new JAXBElement<UnitValue>(_LocationTypeBias_QNAME, UnitValue.class, LocationType.class, value);
    }

    /**
     * Create an instance of {@link JAXBElement }{@code <}{@link Temperature }{@code >}}
     * 
     */
    @XmlElementDecl(namespace = "", name = "temperature", scope = LocationType.class)
    public JAXBElement<Temperature> createLocationTypeTemperature(Temperature value) {
        return new JAXBElement<Temperature>(_LocationTypeTemperature_QNAME, Temperature.class, LocationType.class, value);
    }

    /**
     * Create an instance of {@link JAXBElement }{@code <}{@link LocationType.Weather }{@code >}}
     * 
     */
    @XmlElementDecl(namespace = "", name = "weather", scope = LocationType.class)
    public JAXBElement<LocationType.Weather> createLocationTypeWeather(LocationType.Weather value) {
        return new JAXBElement<LocationType.Weather>(_LocationTypeWeather_QNAME, LocationType.Weather.class, LocationType.class, value);
    }

    /**
     * Create an instance of {@link JAXBElement }{@code <}{@link UnitValue }{@code >}}
     * 
     */
    @XmlElementDecl(namespace = "", name = "humidity", scope = LocationType.class)
    public JAXBElement<UnitValue> createLocationTypeHumidity(UnitValue value) {
        return new JAXBElement<UnitValue>(_LocationTypeHumidity_QNAME, UnitValue.class, LocationType.class, value);
    }

    /**
     * Create an instance of {@link JAXBElement }{@code <}{@link UnitValue }{@code >}}
     * 
     */
    @XmlElementDecl(namespace = "", name = "numberofobservations", scope = LocationType.class)
    public JAXBElement<UnitValue> createLocationTypeNumberofobservations(UnitValue value) {
        return new JAXBElement<UnitValue>(_LocationTypeNumberofobservations_QNAME, UnitValue.class, LocationType.class, value);
    }

    /**
     * Create an instance of {@link JAXBElement }{@code <}{@link LocationType.WindDirection }{@code >}}
     * 
     */
    @XmlElementDecl(namespace = "", name = "windDirection", scope = LocationType.class)
    public JAXBElement<LocationType.WindDirection> createLocationTypeWindDirection(LocationType.WindDirection value) {
        return new JAXBElement<LocationType.WindDirection>(_LocationTypeWindDirection_QNAME, LocationType.WindDirection.class, LocationType.class, value);
    }

    /**
     * Create an instance of {@link JAXBElement }{@code <}{@link Temperature }{@code >}}
     * 
     */
    @XmlElementDecl(namespace = "", name = "maxTemperatureDay", scope = LocationType.class)
    public JAXBElement<Temperature> createLocationTypeMaxTemperatureDay(Temperature value) {
        return new JAXBElement<Temperature>(_LocationTypeMaxTemperatureDay_QNAME, Temperature.class, LocationType.class, value);
    }

    /**
     * Create an instance of {@link JAXBElement }{@code <}{@link Windspeed }{@code >}}
     * 
     */
    @XmlElementDecl(namespace = "", name = "windSpeed", scope = LocationType.class)
    public JAXBElement<Windspeed> createLocationTypeWindSpeed(Windspeed value) {
        return new JAXBElement<Windspeed>(_LocationTypeWindSpeed_QNAME, Windspeed.class, LocationType.class, value);
    }

    /**
     * Create an instance of {@link JAXBElement }{@code <}{@link UnitValue }{@code >}}
     * 
     */
    @XmlElementDecl(namespace = "", name = "wavePeriod", scope = LocationType.class)
    public JAXBElement<UnitValue> createLocationTypeWavePeriod(UnitValue value) {
        return new JAXBElement<UnitValue>(_LocationTypeWavePeriod_QNAME, UnitValue.class, LocationType.class, value);
    }

    /**
     * Create an instance of {@link JAXBElement }{@code <}{@link Temperature }{@code >}}
     * 
     */
    @XmlElementDecl(namespace = "", name = "minTemperatureNight", scope = LocationType.class)
    public JAXBElement<Temperature> createLocationTypeMinTemperatureNight(Temperature value) {
        return new JAXBElement<Temperature>(_LocationTypeMinTemperatureNight_QNAME, Temperature.class, LocationType.class, value);
    }

    /**
     * Create an instance of {@link JAXBElement }{@code <}{@link Uv }{@code >}}
     * 
     */
    @XmlElementDecl(namespace = "", name = "uv", scope = LocationType.class)
    public JAXBElement<Uv> createLocationTypeUv(Uv value) {
        return new JAXBElement<Uv>(_LocationTypeUv_QNAME, Uv.class, LocationType.class, value);
    }

    /**
     * Create an instance of {@link JAXBElement }{@code <}{@link Cloudiness }{@code >}}
     * 
     */
    @XmlElementDecl(namespace = "", name = "highClouds", scope = LocationType.class)
    public JAXBElement<Cloudiness> createLocationTypeHighClouds(Cloudiness value) {
        return new JAXBElement<Cloudiness>(_LocationTypeHighClouds_QNAME, Cloudiness.class, LocationType.class, value);
    }

    /**
     * Create an instance of {@link JAXBElement }{@code <}{@link Temperature }{@code >}}
     * 
     */
    @XmlElementDecl(namespace = "", name = "maxTemperatureNight", scope = LocationType.class)
    public JAXBElement<Temperature> createLocationTypeMaxTemperatureNight(Temperature value) {
        return new JAXBElement<Temperature>(_LocationTypeMaxTemperatureNight_QNAME, Temperature.class, LocationType.class, value);
    }

    /**
     * Create an instance of {@link JAXBElement }{@code <}{@link UnitValue }{@code >}}
     * 
     */
    @XmlElementDecl(namespace = "", name = "windProbability", scope = LocationType.class)
    public JAXBElement<UnitValue> createLocationTypeWindProbability(UnitValue value) {
        return new JAXBElement<UnitValue>(_LocationTypeWindProbability_QNAME, UnitValue.class, LocationType.class, value);
    }

    /**
     * Create an instance of {@link JAXBElement }{@code <}{@link UnitValue }{@code >}}
     * 
     */
    @XmlElementDecl(namespace = "", name = "maxWaveHeight", scope = LocationType.class)
    public JAXBElement<UnitValue> createLocationTypeMaxWaveHeight(UnitValue value) {
        return new JAXBElement<UnitValue>(_LocationTypeMaxWaveHeight_QNAME, UnitValue.class, LocationType.class, value);
    }

    /**
     * Create an instance of {@link JAXBElement }{@code <}{@link UnitValue }{@code >}}
     * 
     */
    @XmlElementDecl(namespace = "", name = "surfaceTemperature", scope = LocationType.class)
    public JAXBElement<UnitValue> createLocationTypeSurfaceTemperature(UnitValue value) {
        return new JAXBElement<UnitValue>(_LocationTypeSurfaceTemperature_QNAME, UnitValue.class, LocationType.class, value);
    }

    /**
     * Create an instance of {@link JAXBElement }{@code <}{@link Pressure }{@code >}}
     * 
     */
    @XmlElementDecl(namespace = "", name = "pressure", scope = LocationType.class)
    public JAXBElement<Pressure> createLocationTypePressure(Pressure value) {
        return new JAXBElement<Pressure>(_LocationTypePressure_QNAME, Pressure.class, LocationType.class, value);
    }

    /**
     * Create an instance of {@link JAXBElement }{@code <}{@link Cloudiness }{@code >}}
     * 
     */
    @XmlElementDecl(namespace = "", name = "cloudiness", scope = LocationType.class)
    public JAXBElement<Cloudiness> createLocationTypeCloudiness(Cloudiness value) {
        return new JAXBElement<Cloudiness>(_LocationTypeCloudiness_QNAME, Cloudiness.class, LocationType.class, value);
    }

    /**
     * Create an instance of {@link JAXBElement }{@code <}{@link UnitValue }{@code >}}
     * 
     */
    @XmlElementDecl(namespace = "", name = "waveDirection", scope = LocationType.class)
    public JAXBElement<UnitValue> createLocationTypeWaveDirection(UnitValue value) {
        return new JAXBElement<UnitValue>(_LocationTypeWaveDirection_QNAME, UnitValue.class, LocationType.class, value);
    }

    /**
     * Create an instance of {@link JAXBElement }{@code <}{@link UnitValue }{@code >}}
     * 
     */
    @XmlElementDecl(namespace = "", name = "symbolProbability", scope = LocationType.class)
    public JAXBElement<UnitValue> createLocationTypeSymbolProbability(UnitValue value) {
        return new JAXBElement<UnitValue>(_LocationTypeSymbolProbability_QNAME, UnitValue.class, LocationType.class, value);
    }

    /**
     * Create an instance of {@link JAXBElement }{@code <}{@link UnitValue }{@code >}}
     * 
     */
    @XmlElementDecl(namespace = "", name = "temperatureProbability", scope = LocationType.class)
    public JAXBElement<UnitValue> createLocationTypeTemperatureProbability(UnitValue value) {
        return new JAXBElement<UnitValue>(_LocationTypeTemperatureProbability_QNAME, UnitValue.class, LocationType.class, value);
    }

    /**
     * Create an instance of {@link JAXBElement }{@code <}{@link Groundcover }{@code >}}
     * 
     */
    @XmlElementDecl(namespace = "", name = "groundCover", scope = LocationType.class)
    public JAXBElement<Groundcover> createLocationTypeGroundCover(Groundcover value) {
        return new JAXBElement<Groundcover>(_LocationTypeGroundCover_QNAME, Groundcover.class, LocationType.class, value);
    }

    /**
     * Create an instance of {@link JAXBElement }{@code <}{@link Temperature }{@code >}}
     * 
     */
    @XmlElementDecl(namespace = "", name = "minTemperatureDay", scope = LocationType.class)
    public JAXBElement<Temperature> createLocationTypeMinTemperatureDay(Temperature value) {
        return new JAXBElement<Temperature>(_LocationTypeMinTemperatureDay_QNAME, Temperature.class, LocationType.class, value);
    }

    /**
     * Create an instance of {@link JAXBElement }{@code <}{@link Windspeed }{@code >}}
     * 
     */
    @XmlElementDecl(namespace = "", name = "maxWindSpeed", scope = LocationType.class)
    public JAXBElement<Windspeed> createLocationTypeMaxWindSpeed(Windspeed value) {
        return new JAXBElement<Windspeed>(_LocationTypeMaxWindSpeed_QNAME, Windspeed.class, LocationType.class, value);
    }

    /**
     * Create an instance of {@link JAXBElement }{@code <}{@link LocationType.ForestFire }{@code >}}
     * 
     */
    @XmlElementDecl(namespace = "", name = "forest-fire", scope = LocationType.class)
    public JAXBElement<LocationType.ForestFire> createLocationTypeForestFire(LocationType.ForestFire value) {
        return new JAXBElement<LocationType.ForestFire>(_LocationTypeForestFire_QNAME, LocationType.ForestFire.class, LocationType.class, value);
    }

    /**
     * Create an instance of {@link JAXBElement }{@code <}{@link Cloudiness }{@code >}}
     * 
     */
    @XmlElementDecl(namespace = "", name = "mediumClouds", scope = LocationType.class)
    public JAXBElement<Cloudiness> createLocationTypeMediumClouds(Cloudiness value) {
        return new JAXBElement<Cloudiness>(_LocationTypeMediumClouds_QNAME, Cloudiness.class, LocationType.class, value);
    }

    /**
     * Create an instance of {@link JAXBElement }{@code <}{@link Temperature }{@code >}}
     * 
     */
    @XmlElementDecl(namespace = "", name = "dewpointTemperature", scope = LocationType.class)
    public JAXBElement<Temperature> createLocationTypeDewpointTemperature(Temperature value) {
        return new JAXBElement<Temperature>(_LocationTypeDewpointTemperature_QNAME, Temperature.class, LocationType.class, value);
    }

    /**
     * Create an instance of {@link JAXBElement }{@code <}{@link Temperature }{@code >}}
     * 
     */
    @XmlElementDecl(namespace = "", name = "lowestTemperature", scope = LocationType.class)
    public JAXBElement<Temperature> createLocationTypeLowestTemperature(Temperature value) {
        return new JAXBElement<Temperature>(_LocationTypeLowestTemperature_QNAME, Temperature.class, LocationType.class, value);
    }

    /**
     * Create an instance of {@link JAXBElement }{@code <}{@link Cloudiness }{@code >}}
     * 
     */
    @XmlElementDecl(namespace = "", name = "fog", scope = LocationType.class)
    public JAXBElement<Cloudiness> createLocationTypeFog(Cloudiness value) {
        return new JAXBElement<Cloudiness>(_LocationTypeFog_QNAME, Cloudiness.class, LocationType.class, value);
    }

}