# automatically generated by the FlatBuffers compiler, do not modify

# namespace: openmeteo_sdk

import flatbuffers
from flatbuffers.compat import import_numpy
from typing import Any
from openmeteo_sdk.TimeRange import TimeRange
from openmeteo_sdk.ValuesUnitAndMember import ValuesUnitAndMember
from typing import Optional
np = import_numpy()

class EnsembleDaily(object):
    __slots__ = ['_tab']

    @classmethod
    def GetRootAs(cls, buf, offset: int = 0):
        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
        x = EnsembleDaily()
        x.Init(buf, n + offset)
        return x

    @classmethod
    def GetRootAsEnsembleDaily(cls, buf, offset=0):
        """This method is deprecated. Please switch to GetRootAs."""
        return cls.GetRootAs(buf, offset)
    # EnsembleDaily
    def Init(self, buf: bytes, pos: int):
        self._tab = flatbuffers.table.Table(buf, pos)

    # EnsembleDaily
    def Time(self) -> Optional[TimeRange]:
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
        if o != 0:
            x = o + self._tab.Pos
            obj = TimeRange()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # EnsembleDaily
    def ApparentTemperatureMax(self) -> Optional[ValuesUnitAndMember]:
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            obj = ValuesUnitAndMember()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # EnsembleDaily
    def ApparentTemperatureMean(self) -> Optional[ValuesUnitAndMember]:
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            obj = ValuesUnitAndMember()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # EnsembleDaily
    def ApparentTemperatureMin(self) -> Optional[ValuesUnitAndMember]:
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            obj = ValuesUnitAndMember()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # EnsembleDaily
    def CapeMax(self) -> Optional[ValuesUnitAndMember]:
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            obj = ValuesUnitAndMember()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # EnsembleDaily
    def CapeMean(self) -> Optional[ValuesUnitAndMember]:
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            obj = ValuesUnitAndMember()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # EnsembleDaily
    def CapeMin(self) -> Optional[ValuesUnitAndMember]:
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            obj = ValuesUnitAndMember()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # EnsembleDaily
    def CloudcoverMax(self) -> Optional[ValuesUnitAndMember]:
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            obj = ValuesUnitAndMember()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # EnsembleDaily
    def CloudcoverMean(self) -> Optional[ValuesUnitAndMember]:
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            obj = ValuesUnitAndMember()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # EnsembleDaily
    def CloudcoverMin(self) -> Optional[ValuesUnitAndMember]:
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            obj = ValuesUnitAndMember()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # EnsembleDaily
    def Dewpoint2mMax(self) -> Optional[ValuesUnitAndMember]:
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            obj = ValuesUnitAndMember()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # EnsembleDaily
    def Dewpoint2mMean(self) -> Optional[ValuesUnitAndMember]:
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            obj = ValuesUnitAndMember()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # EnsembleDaily
    def Dewpoint2mMin(self) -> Optional[ValuesUnitAndMember]:
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            obj = ValuesUnitAndMember()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # EnsembleDaily
    def Et0FaoEvapotranspiration(self) -> Optional[ValuesUnitAndMember]:
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            obj = ValuesUnitAndMember()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # EnsembleDaily
    def Et0FaoEvapotranspirationSum(self) -> Optional[ValuesUnitAndMember]:
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            obj = ValuesUnitAndMember()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # EnsembleDaily
    def GrowingDegreeDaysBase0Limit50(self) -> Optional[ValuesUnitAndMember]:
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(34))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            obj = ValuesUnitAndMember()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # EnsembleDaily
    def LeafWetnessProbabilityMean(self) -> Optional[ValuesUnitAndMember]:
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(36))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            obj = ValuesUnitAndMember()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # EnsembleDaily
    def PrecipitationHours(self) -> Optional[ValuesUnitAndMember]:
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(38))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            obj = ValuesUnitAndMember()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # EnsembleDaily
    def PrecipitationProbabilityMax(self) -> Optional[ValuesUnitAndMember]:
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(40))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            obj = ValuesUnitAndMember()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # EnsembleDaily
    def PrecipitationProbabilityMean(self) -> Optional[ValuesUnitAndMember]:
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(42))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            obj = ValuesUnitAndMember()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # EnsembleDaily
    def PrecipitationProbabilityMin(self) -> Optional[ValuesUnitAndMember]:
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(44))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            obj = ValuesUnitAndMember()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # EnsembleDaily
    def PrecipitationSum(self) -> Optional[ValuesUnitAndMember]:
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(46))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            obj = ValuesUnitAndMember()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # EnsembleDaily
    def PressureMslMax(self) -> Optional[ValuesUnitAndMember]:
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(48))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            obj = ValuesUnitAndMember()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # EnsembleDaily
    def PressureMslMean(self) -> Optional[ValuesUnitAndMember]:
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(50))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            obj = ValuesUnitAndMember()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # EnsembleDaily
    def PressureMslMin(self) -> Optional[ValuesUnitAndMember]:
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(52))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            obj = ValuesUnitAndMember()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # EnsembleDaily
    def RainSum(self) -> Optional[ValuesUnitAndMember]:
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(54))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            obj = ValuesUnitAndMember()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # EnsembleDaily
    def RelativeHumidity2mMax(self) -> Optional[ValuesUnitAndMember]:
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(56))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            obj = ValuesUnitAndMember()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # EnsembleDaily
    def RelativeHumidity2mMean(self) -> Optional[ValuesUnitAndMember]:
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(58))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            obj = ValuesUnitAndMember()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # EnsembleDaily
    def RelativeHumidity2mMin(self) -> Optional[ValuesUnitAndMember]:
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(60))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            obj = ValuesUnitAndMember()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # EnsembleDaily
    def ShortwaveRadiationSum(self) -> Optional[ValuesUnitAndMember]:
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(62))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            obj = ValuesUnitAndMember()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # EnsembleDaily
    def ShowersSum(self) -> Optional[ValuesUnitAndMember]:
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(64))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            obj = ValuesUnitAndMember()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # EnsembleDaily
    def SnowfallSum(self) -> Optional[ValuesUnitAndMember]:
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(66))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            obj = ValuesUnitAndMember()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # EnsembleDaily
    def SnowfallWaterEquivalentSum(self) -> Optional[ValuesUnitAndMember]:
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(68))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            obj = ValuesUnitAndMember()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # EnsembleDaily
    def SoilMoisture0To100cmMean(self) -> Optional[ValuesUnitAndMember]:
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(70))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            obj = ValuesUnitAndMember()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # EnsembleDaily
    def SoilMoisture0To10cmMean(self) -> Optional[ValuesUnitAndMember]:
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(72))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            obj = ValuesUnitAndMember()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # EnsembleDaily
    def SoilMoisture0To7cmMean(self) -> Optional[ValuesUnitAndMember]:
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(74))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            obj = ValuesUnitAndMember()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # EnsembleDaily
    def SoilMoisture28To100cmMean(self) -> Optional[ValuesUnitAndMember]:
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(76))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            obj = ValuesUnitAndMember()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # EnsembleDaily
    def SoilMoisture7To28cmMean(self) -> Optional[ValuesUnitAndMember]:
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(78))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            obj = ValuesUnitAndMember()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # EnsembleDaily
    def SoilMoistureIndex0To100cmMean(self) -> Optional[ValuesUnitAndMember]:
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(80))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            obj = ValuesUnitAndMember()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # EnsembleDaily
    def SoilMoistureIndex0To7cmMean(self) -> Optional[ValuesUnitAndMember]:
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(82))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            obj = ValuesUnitAndMember()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # EnsembleDaily
    def SoilMoistureIndex100To255cmMean(self) -> Optional[ValuesUnitAndMember]:
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(84))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            obj = ValuesUnitAndMember()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # EnsembleDaily
    def SoilMoistureIndex28To100cmMean(self) -> Optional[ValuesUnitAndMember]:
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(86))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            obj = ValuesUnitAndMember()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # EnsembleDaily
    def SoilMoistureIndex7To28cmMean(self) -> Optional[ValuesUnitAndMember]:
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(88))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            obj = ValuesUnitAndMember()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # EnsembleDaily
    def SoilTemperature0To100cmMean(self) -> Optional[ValuesUnitAndMember]:
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(90))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            obj = ValuesUnitAndMember()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # EnsembleDaily
    def SoilTemperature0To7cmMean(self) -> Optional[ValuesUnitAndMember]:
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(92))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            obj = ValuesUnitAndMember()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # EnsembleDaily
    def SoilTemperature28To100cmMean(self) -> Optional[ValuesUnitAndMember]:
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(94))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            obj = ValuesUnitAndMember()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # EnsembleDaily
    def SoilTemperature7To28cmMean(self) -> Optional[ValuesUnitAndMember]:
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(96))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            obj = ValuesUnitAndMember()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # EnsembleDaily
    def SurfacePressureMax(self) -> Optional[ValuesUnitAndMember]:
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(98))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            obj = ValuesUnitAndMember()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # EnsembleDaily
    def SurfacePressureMean(self) -> Optional[ValuesUnitAndMember]:
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(100))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            obj = ValuesUnitAndMember()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # EnsembleDaily
    def SurfacePressureMin(self) -> Optional[ValuesUnitAndMember]:
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(102))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            obj = ValuesUnitAndMember()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # EnsembleDaily
    def Temperature2mMax(self) -> Optional[ValuesUnitAndMember]:
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(104))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            obj = ValuesUnitAndMember()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # EnsembleDaily
    def Temperature2mMean(self) -> Optional[ValuesUnitAndMember]:
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(106))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            obj = ValuesUnitAndMember()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # EnsembleDaily
    def Temperature2mMin(self) -> Optional[ValuesUnitAndMember]:
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(108))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            obj = ValuesUnitAndMember()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # EnsembleDaily
    def UpdraftMax(self) -> Optional[ValuesUnitAndMember]:
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(110))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            obj = ValuesUnitAndMember()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # EnsembleDaily
    def UvIndexClearSkyMax(self) -> Optional[ValuesUnitAndMember]:
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(112))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            obj = ValuesUnitAndMember()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # EnsembleDaily
    def UvIndexMax(self) -> Optional[ValuesUnitAndMember]:
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(114))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            obj = ValuesUnitAndMember()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # EnsembleDaily
    def VaporPressureDeficitMax(self) -> Optional[ValuesUnitAndMember]:
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(116))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            obj = ValuesUnitAndMember()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # EnsembleDaily
    def VisibilityMax(self) -> Optional[ValuesUnitAndMember]:
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(118))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            obj = ValuesUnitAndMember()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # EnsembleDaily
    def VisibilityMean(self) -> Optional[ValuesUnitAndMember]:
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(120))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            obj = ValuesUnitAndMember()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # EnsembleDaily
    def VisibilityMin(self) -> Optional[ValuesUnitAndMember]:
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(122))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            obj = ValuesUnitAndMember()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # EnsembleDaily
    def Weathercode(self) -> Optional[ValuesUnitAndMember]:
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(124))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            obj = ValuesUnitAndMember()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # EnsembleDaily
    def Winddirection10mDominant(self) -> Optional[ValuesUnitAndMember]:
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(126))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            obj = ValuesUnitAndMember()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # EnsembleDaily
    def Windgusts10mMax(self) -> Optional[ValuesUnitAndMember]:
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(128))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            obj = ValuesUnitAndMember()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # EnsembleDaily
    def Windgusts10mMean(self) -> Optional[ValuesUnitAndMember]:
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(130))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            obj = ValuesUnitAndMember()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # EnsembleDaily
    def Windgusts10mMin(self) -> Optional[ValuesUnitAndMember]:
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(132))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            obj = ValuesUnitAndMember()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # EnsembleDaily
    def Windspeed10mMax(self) -> Optional[ValuesUnitAndMember]:
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(134))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            obj = ValuesUnitAndMember()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # EnsembleDaily
    def Windspeed10mMean(self) -> Optional[ValuesUnitAndMember]:
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(136))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            obj = ValuesUnitAndMember()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # EnsembleDaily
    def Windspeed10mMin(self) -> Optional[ValuesUnitAndMember]:
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(138))
        if o != 0:
            x = self._tab.Indirect(o + self._tab.Pos)
            obj = ValuesUnitAndMember()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

def EnsembleDailyStart(builder: flatbuffers.Builder):
    builder.StartObject(68)

def Start(builder: flatbuffers.Builder):
    EnsembleDailyStart(builder)

def EnsembleDailyAddTime(builder: flatbuffers.Builder, time: Any):
    builder.PrependStructSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(time), 0)

def AddTime(builder: flatbuffers.Builder, time: Any):
    EnsembleDailyAddTime(builder, time)

def EnsembleDailyAddApparentTemperatureMax(builder: flatbuffers.Builder, apparentTemperatureMax: int):
    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(apparentTemperatureMax), 0)

def AddApparentTemperatureMax(builder: flatbuffers.Builder, apparentTemperatureMax: int):
    EnsembleDailyAddApparentTemperatureMax(builder, apparentTemperatureMax)

def EnsembleDailyAddApparentTemperatureMean(builder: flatbuffers.Builder, apparentTemperatureMean: int):
    builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(apparentTemperatureMean), 0)

def AddApparentTemperatureMean(builder: flatbuffers.Builder, apparentTemperatureMean: int):
    EnsembleDailyAddApparentTemperatureMean(builder, apparentTemperatureMean)

def EnsembleDailyAddApparentTemperatureMin(builder: flatbuffers.Builder, apparentTemperatureMin: int):
    builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(apparentTemperatureMin), 0)

def AddApparentTemperatureMin(builder: flatbuffers.Builder, apparentTemperatureMin: int):
    EnsembleDailyAddApparentTemperatureMin(builder, apparentTemperatureMin)

def EnsembleDailyAddCapeMax(builder: flatbuffers.Builder, capeMax: int):
    builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(capeMax), 0)

def AddCapeMax(builder: flatbuffers.Builder, capeMax: int):
    EnsembleDailyAddCapeMax(builder, capeMax)

def EnsembleDailyAddCapeMean(builder: flatbuffers.Builder, capeMean: int):
    builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(capeMean), 0)

def AddCapeMean(builder: flatbuffers.Builder, capeMean: int):
    EnsembleDailyAddCapeMean(builder, capeMean)

def EnsembleDailyAddCapeMin(builder: flatbuffers.Builder, capeMin: int):
    builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(capeMin), 0)

def AddCapeMin(builder: flatbuffers.Builder, capeMin: int):
    EnsembleDailyAddCapeMin(builder, capeMin)

def EnsembleDailyAddCloudcoverMax(builder: flatbuffers.Builder, cloudcoverMax: int):
    builder.PrependUOffsetTRelativeSlot(7, flatbuffers.number_types.UOffsetTFlags.py_type(cloudcoverMax), 0)

def AddCloudcoverMax(builder: flatbuffers.Builder, cloudcoverMax: int):
    EnsembleDailyAddCloudcoverMax(builder, cloudcoverMax)

def EnsembleDailyAddCloudcoverMean(builder: flatbuffers.Builder, cloudcoverMean: int):
    builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(cloudcoverMean), 0)

def AddCloudcoverMean(builder: flatbuffers.Builder, cloudcoverMean: int):
    EnsembleDailyAddCloudcoverMean(builder, cloudcoverMean)

def EnsembleDailyAddCloudcoverMin(builder: flatbuffers.Builder, cloudcoverMin: int):
    builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(cloudcoverMin), 0)

def AddCloudcoverMin(builder: flatbuffers.Builder, cloudcoverMin: int):
    EnsembleDailyAddCloudcoverMin(builder, cloudcoverMin)

def EnsembleDailyAddDewpoint2mMax(builder: flatbuffers.Builder, dewpoint2mMax: int):
    builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(dewpoint2mMax), 0)

def AddDewpoint2mMax(builder: flatbuffers.Builder, dewpoint2mMax: int):
    EnsembleDailyAddDewpoint2mMax(builder, dewpoint2mMax)

def EnsembleDailyAddDewpoint2mMean(builder: flatbuffers.Builder, dewpoint2mMean: int):
    builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(dewpoint2mMean), 0)

def AddDewpoint2mMean(builder: flatbuffers.Builder, dewpoint2mMean: int):
    EnsembleDailyAddDewpoint2mMean(builder, dewpoint2mMean)

def EnsembleDailyAddDewpoint2mMin(builder: flatbuffers.Builder, dewpoint2mMin: int):
    builder.PrependUOffsetTRelativeSlot(12, flatbuffers.number_types.UOffsetTFlags.py_type(dewpoint2mMin), 0)

def AddDewpoint2mMin(builder: flatbuffers.Builder, dewpoint2mMin: int):
    EnsembleDailyAddDewpoint2mMin(builder, dewpoint2mMin)

def EnsembleDailyAddEt0FaoEvapotranspiration(builder: flatbuffers.Builder, et0FaoEvapotranspiration: int):
    builder.PrependUOffsetTRelativeSlot(13, flatbuffers.number_types.UOffsetTFlags.py_type(et0FaoEvapotranspiration), 0)

def AddEt0FaoEvapotranspiration(builder: flatbuffers.Builder, et0FaoEvapotranspiration: int):
    EnsembleDailyAddEt0FaoEvapotranspiration(builder, et0FaoEvapotranspiration)

def EnsembleDailyAddEt0FaoEvapotranspirationSum(builder: flatbuffers.Builder, et0FaoEvapotranspirationSum: int):
    builder.PrependUOffsetTRelativeSlot(14, flatbuffers.number_types.UOffsetTFlags.py_type(et0FaoEvapotranspirationSum), 0)

def AddEt0FaoEvapotranspirationSum(builder: flatbuffers.Builder, et0FaoEvapotranspirationSum: int):
    EnsembleDailyAddEt0FaoEvapotranspirationSum(builder, et0FaoEvapotranspirationSum)

def EnsembleDailyAddGrowingDegreeDaysBase0Limit50(builder: flatbuffers.Builder, growingDegreeDaysBase0Limit50: int):
    builder.PrependUOffsetTRelativeSlot(15, flatbuffers.number_types.UOffsetTFlags.py_type(growingDegreeDaysBase0Limit50), 0)

def AddGrowingDegreeDaysBase0Limit50(builder: flatbuffers.Builder, growingDegreeDaysBase0Limit50: int):
    EnsembleDailyAddGrowingDegreeDaysBase0Limit50(builder, growingDegreeDaysBase0Limit50)

def EnsembleDailyAddLeafWetnessProbabilityMean(builder: flatbuffers.Builder, leafWetnessProbabilityMean: int):
    builder.PrependUOffsetTRelativeSlot(16, flatbuffers.number_types.UOffsetTFlags.py_type(leafWetnessProbabilityMean), 0)

def AddLeafWetnessProbabilityMean(builder: flatbuffers.Builder, leafWetnessProbabilityMean: int):
    EnsembleDailyAddLeafWetnessProbabilityMean(builder, leafWetnessProbabilityMean)

def EnsembleDailyAddPrecipitationHours(builder: flatbuffers.Builder, precipitationHours: int):
    builder.PrependUOffsetTRelativeSlot(17, flatbuffers.number_types.UOffsetTFlags.py_type(precipitationHours), 0)

def AddPrecipitationHours(builder: flatbuffers.Builder, precipitationHours: int):
    EnsembleDailyAddPrecipitationHours(builder, precipitationHours)

def EnsembleDailyAddPrecipitationProbabilityMax(builder: flatbuffers.Builder, precipitationProbabilityMax: int):
    builder.PrependUOffsetTRelativeSlot(18, flatbuffers.number_types.UOffsetTFlags.py_type(precipitationProbabilityMax), 0)

def AddPrecipitationProbabilityMax(builder: flatbuffers.Builder, precipitationProbabilityMax: int):
    EnsembleDailyAddPrecipitationProbabilityMax(builder, precipitationProbabilityMax)

def EnsembleDailyAddPrecipitationProbabilityMean(builder: flatbuffers.Builder, precipitationProbabilityMean: int):
    builder.PrependUOffsetTRelativeSlot(19, flatbuffers.number_types.UOffsetTFlags.py_type(precipitationProbabilityMean), 0)

def AddPrecipitationProbabilityMean(builder: flatbuffers.Builder, precipitationProbabilityMean: int):
    EnsembleDailyAddPrecipitationProbabilityMean(builder, precipitationProbabilityMean)

def EnsembleDailyAddPrecipitationProbabilityMin(builder: flatbuffers.Builder, precipitationProbabilityMin: int):
    builder.PrependUOffsetTRelativeSlot(20, flatbuffers.number_types.UOffsetTFlags.py_type(precipitationProbabilityMin), 0)

def AddPrecipitationProbabilityMin(builder: flatbuffers.Builder, precipitationProbabilityMin: int):
    EnsembleDailyAddPrecipitationProbabilityMin(builder, precipitationProbabilityMin)

def EnsembleDailyAddPrecipitationSum(builder: flatbuffers.Builder, precipitationSum: int):
    builder.PrependUOffsetTRelativeSlot(21, flatbuffers.number_types.UOffsetTFlags.py_type(precipitationSum), 0)

def AddPrecipitationSum(builder: flatbuffers.Builder, precipitationSum: int):
    EnsembleDailyAddPrecipitationSum(builder, precipitationSum)

def EnsembleDailyAddPressureMslMax(builder: flatbuffers.Builder, pressureMslMax: int):
    builder.PrependUOffsetTRelativeSlot(22, flatbuffers.number_types.UOffsetTFlags.py_type(pressureMslMax), 0)

def AddPressureMslMax(builder: flatbuffers.Builder, pressureMslMax: int):
    EnsembleDailyAddPressureMslMax(builder, pressureMslMax)

def EnsembleDailyAddPressureMslMean(builder: flatbuffers.Builder, pressureMslMean: int):
    builder.PrependUOffsetTRelativeSlot(23, flatbuffers.number_types.UOffsetTFlags.py_type(pressureMslMean), 0)

def AddPressureMslMean(builder: flatbuffers.Builder, pressureMslMean: int):
    EnsembleDailyAddPressureMslMean(builder, pressureMslMean)

def EnsembleDailyAddPressureMslMin(builder: flatbuffers.Builder, pressureMslMin: int):
    builder.PrependUOffsetTRelativeSlot(24, flatbuffers.number_types.UOffsetTFlags.py_type(pressureMslMin), 0)

def AddPressureMslMin(builder: flatbuffers.Builder, pressureMslMin: int):
    EnsembleDailyAddPressureMslMin(builder, pressureMslMin)

def EnsembleDailyAddRainSum(builder: flatbuffers.Builder, rainSum: int):
    builder.PrependUOffsetTRelativeSlot(25, flatbuffers.number_types.UOffsetTFlags.py_type(rainSum), 0)

def AddRainSum(builder: flatbuffers.Builder, rainSum: int):
    EnsembleDailyAddRainSum(builder, rainSum)

def EnsembleDailyAddRelativeHumidity2mMax(builder: flatbuffers.Builder, relativeHumidity2mMax: int):
    builder.PrependUOffsetTRelativeSlot(26, flatbuffers.number_types.UOffsetTFlags.py_type(relativeHumidity2mMax), 0)

def AddRelativeHumidity2mMax(builder: flatbuffers.Builder, relativeHumidity2mMax: int):
    EnsembleDailyAddRelativeHumidity2mMax(builder, relativeHumidity2mMax)

def EnsembleDailyAddRelativeHumidity2mMean(builder: flatbuffers.Builder, relativeHumidity2mMean: int):
    builder.PrependUOffsetTRelativeSlot(27, flatbuffers.number_types.UOffsetTFlags.py_type(relativeHumidity2mMean), 0)

def AddRelativeHumidity2mMean(builder: flatbuffers.Builder, relativeHumidity2mMean: int):
    EnsembleDailyAddRelativeHumidity2mMean(builder, relativeHumidity2mMean)

def EnsembleDailyAddRelativeHumidity2mMin(builder: flatbuffers.Builder, relativeHumidity2mMin: int):
    builder.PrependUOffsetTRelativeSlot(28, flatbuffers.number_types.UOffsetTFlags.py_type(relativeHumidity2mMin), 0)

def AddRelativeHumidity2mMin(builder: flatbuffers.Builder, relativeHumidity2mMin: int):
    EnsembleDailyAddRelativeHumidity2mMin(builder, relativeHumidity2mMin)

def EnsembleDailyAddShortwaveRadiationSum(builder: flatbuffers.Builder, shortwaveRadiationSum: int):
    builder.PrependUOffsetTRelativeSlot(29, flatbuffers.number_types.UOffsetTFlags.py_type(shortwaveRadiationSum), 0)

def AddShortwaveRadiationSum(builder: flatbuffers.Builder, shortwaveRadiationSum: int):
    EnsembleDailyAddShortwaveRadiationSum(builder, shortwaveRadiationSum)

def EnsembleDailyAddShowersSum(builder: flatbuffers.Builder, showersSum: int):
    builder.PrependUOffsetTRelativeSlot(30, flatbuffers.number_types.UOffsetTFlags.py_type(showersSum), 0)

def AddShowersSum(builder: flatbuffers.Builder, showersSum: int):
    EnsembleDailyAddShowersSum(builder, showersSum)

def EnsembleDailyAddSnowfallSum(builder: flatbuffers.Builder, snowfallSum: int):
    builder.PrependUOffsetTRelativeSlot(31, flatbuffers.number_types.UOffsetTFlags.py_type(snowfallSum), 0)

def AddSnowfallSum(builder: flatbuffers.Builder, snowfallSum: int):
    EnsembleDailyAddSnowfallSum(builder, snowfallSum)

def EnsembleDailyAddSnowfallWaterEquivalentSum(builder: flatbuffers.Builder, snowfallWaterEquivalentSum: int):
    builder.PrependUOffsetTRelativeSlot(32, flatbuffers.number_types.UOffsetTFlags.py_type(snowfallWaterEquivalentSum), 0)

def AddSnowfallWaterEquivalentSum(builder: flatbuffers.Builder, snowfallWaterEquivalentSum: int):
    EnsembleDailyAddSnowfallWaterEquivalentSum(builder, snowfallWaterEquivalentSum)

def EnsembleDailyAddSoilMoisture0To100cmMean(builder: flatbuffers.Builder, soilMoisture0To100cmMean: int):
    builder.PrependUOffsetTRelativeSlot(33, flatbuffers.number_types.UOffsetTFlags.py_type(soilMoisture0To100cmMean), 0)

def AddSoilMoisture0To100cmMean(builder: flatbuffers.Builder, soilMoisture0To100cmMean: int):
    EnsembleDailyAddSoilMoisture0To100cmMean(builder, soilMoisture0To100cmMean)

def EnsembleDailyAddSoilMoisture0To10cmMean(builder: flatbuffers.Builder, soilMoisture0To10cmMean: int):
    builder.PrependUOffsetTRelativeSlot(34, flatbuffers.number_types.UOffsetTFlags.py_type(soilMoisture0To10cmMean), 0)

def AddSoilMoisture0To10cmMean(builder: flatbuffers.Builder, soilMoisture0To10cmMean: int):
    EnsembleDailyAddSoilMoisture0To10cmMean(builder, soilMoisture0To10cmMean)

def EnsembleDailyAddSoilMoisture0To7cmMean(builder: flatbuffers.Builder, soilMoisture0To7cmMean: int):
    builder.PrependUOffsetTRelativeSlot(35, flatbuffers.number_types.UOffsetTFlags.py_type(soilMoisture0To7cmMean), 0)

def AddSoilMoisture0To7cmMean(builder: flatbuffers.Builder, soilMoisture0To7cmMean: int):
    EnsembleDailyAddSoilMoisture0To7cmMean(builder, soilMoisture0To7cmMean)

def EnsembleDailyAddSoilMoisture28To100cmMean(builder: flatbuffers.Builder, soilMoisture28To100cmMean: int):
    builder.PrependUOffsetTRelativeSlot(36, flatbuffers.number_types.UOffsetTFlags.py_type(soilMoisture28To100cmMean), 0)

def AddSoilMoisture28To100cmMean(builder: flatbuffers.Builder, soilMoisture28To100cmMean: int):
    EnsembleDailyAddSoilMoisture28To100cmMean(builder, soilMoisture28To100cmMean)

def EnsembleDailyAddSoilMoisture7To28cmMean(builder: flatbuffers.Builder, soilMoisture7To28cmMean: int):
    builder.PrependUOffsetTRelativeSlot(37, flatbuffers.number_types.UOffsetTFlags.py_type(soilMoisture7To28cmMean), 0)

def AddSoilMoisture7To28cmMean(builder: flatbuffers.Builder, soilMoisture7To28cmMean: int):
    EnsembleDailyAddSoilMoisture7To28cmMean(builder, soilMoisture7To28cmMean)

def EnsembleDailyAddSoilMoistureIndex0To100cmMean(builder: flatbuffers.Builder, soilMoistureIndex0To100cmMean: int):
    builder.PrependUOffsetTRelativeSlot(38, flatbuffers.number_types.UOffsetTFlags.py_type(soilMoistureIndex0To100cmMean), 0)

def AddSoilMoistureIndex0To100cmMean(builder: flatbuffers.Builder, soilMoistureIndex0To100cmMean: int):
    EnsembleDailyAddSoilMoistureIndex0To100cmMean(builder, soilMoistureIndex0To100cmMean)

def EnsembleDailyAddSoilMoistureIndex0To7cmMean(builder: flatbuffers.Builder, soilMoistureIndex0To7cmMean: int):
    builder.PrependUOffsetTRelativeSlot(39, flatbuffers.number_types.UOffsetTFlags.py_type(soilMoistureIndex0To7cmMean), 0)

def AddSoilMoistureIndex0To7cmMean(builder: flatbuffers.Builder, soilMoistureIndex0To7cmMean: int):
    EnsembleDailyAddSoilMoistureIndex0To7cmMean(builder, soilMoistureIndex0To7cmMean)

def EnsembleDailyAddSoilMoistureIndex100To255cmMean(builder: flatbuffers.Builder, soilMoistureIndex100To255cmMean: int):
    builder.PrependUOffsetTRelativeSlot(40, flatbuffers.number_types.UOffsetTFlags.py_type(soilMoistureIndex100To255cmMean), 0)

def AddSoilMoistureIndex100To255cmMean(builder: flatbuffers.Builder, soilMoistureIndex100To255cmMean: int):
    EnsembleDailyAddSoilMoistureIndex100To255cmMean(builder, soilMoistureIndex100To255cmMean)

def EnsembleDailyAddSoilMoistureIndex28To100cmMean(builder: flatbuffers.Builder, soilMoistureIndex28To100cmMean: int):
    builder.PrependUOffsetTRelativeSlot(41, flatbuffers.number_types.UOffsetTFlags.py_type(soilMoistureIndex28To100cmMean), 0)

def AddSoilMoistureIndex28To100cmMean(builder: flatbuffers.Builder, soilMoistureIndex28To100cmMean: int):
    EnsembleDailyAddSoilMoistureIndex28To100cmMean(builder, soilMoistureIndex28To100cmMean)

def EnsembleDailyAddSoilMoistureIndex7To28cmMean(builder: flatbuffers.Builder, soilMoistureIndex7To28cmMean: int):
    builder.PrependUOffsetTRelativeSlot(42, flatbuffers.number_types.UOffsetTFlags.py_type(soilMoistureIndex7To28cmMean), 0)

def AddSoilMoistureIndex7To28cmMean(builder: flatbuffers.Builder, soilMoistureIndex7To28cmMean: int):
    EnsembleDailyAddSoilMoistureIndex7To28cmMean(builder, soilMoistureIndex7To28cmMean)

def EnsembleDailyAddSoilTemperature0To100cmMean(builder: flatbuffers.Builder, soilTemperature0To100cmMean: int):
    builder.PrependUOffsetTRelativeSlot(43, flatbuffers.number_types.UOffsetTFlags.py_type(soilTemperature0To100cmMean), 0)

def AddSoilTemperature0To100cmMean(builder: flatbuffers.Builder, soilTemperature0To100cmMean: int):
    EnsembleDailyAddSoilTemperature0To100cmMean(builder, soilTemperature0To100cmMean)

def EnsembleDailyAddSoilTemperature0To7cmMean(builder: flatbuffers.Builder, soilTemperature0To7cmMean: int):
    builder.PrependUOffsetTRelativeSlot(44, flatbuffers.number_types.UOffsetTFlags.py_type(soilTemperature0To7cmMean), 0)

def AddSoilTemperature0To7cmMean(builder: flatbuffers.Builder, soilTemperature0To7cmMean: int):
    EnsembleDailyAddSoilTemperature0To7cmMean(builder, soilTemperature0To7cmMean)

def EnsembleDailyAddSoilTemperature28To100cmMean(builder: flatbuffers.Builder, soilTemperature28To100cmMean: int):
    builder.PrependUOffsetTRelativeSlot(45, flatbuffers.number_types.UOffsetTFlags.py_type(soilTemperature28To100cmMean), 0)

def AddSoilTemperature28To100cmMean(builder: flatbuffers.Builder, soilTemperature28To100cmMean: int):
    EnsembleDailyAddSoilTemperature28To100cmMean(builder, soilTemperature28To100cmMean)

def EnsembleDailyAddSoilTemperature7To28cmMean(builder: flatbuffers.Builder, soilTemperature7To28cmMean: int):
    builder.PrependUOffsetTRelativeSlot(46, flatbuffers.number_types.UOffsetTFlags.py_type(soilTemperature7To28cmMean), 0)

def AddSoilTemperature7To28cmMean(builder: flatbuffers.Builder, soilTemperature7To28cmMean: int):
    EnsembleDailyAddSoilTemperature7To28cmMean(builder, soilTemperature7To28cmMean)

def EnsembleDailyAddSurfacePressureMax(builder: flatbuffers.Builder, surfacePressureMax: int):
    builder.PrependUOffsetTRelativeSlot(47, flatbuffers.number_types.UOffsetTFlags.py_type(surfacePressureMax), 0)

def AddSurfacePressureMax(builder: flatbuffers.Builder, surfacePressureMax: int):
    EnsembleDailyAddSurfacePressureMax(builder, surfacePressureMax)

def EnsembleDailyAddSurfacePressureMean(builder: flatbuffers.Builder, surfacePressureMean: int):
    builder.PrependUOffsetTRelativeSlot(48, flatbuffers.number_types.UOffsetTFlags.py_type(surfacePressureMean), 0)

def AddSurfacePressureMean(builder: flatbuffers.Builder, surfacePressureMean: int):
    EnsembleDailyAddSurfacePressureMean(builder, surfacePressureMean)

def EnsembleDailyAddSurfacePressureMin(builder: flatbuffers.Builder, surfacePressureMin: int):
    builder.PrependUOffsetTRelativeSlot(49, flatbuffers.number_types.UOffsetTFlags.py_type(surfacePressureMin), 0)

def AddSurfacePressureMin(builder: flatbuffers.Builder, surfacePressureMin: int):
    EnsembleDailyAddSurfacePressureMin(builder, surfacePressureMin)

def EnsembleDailyAddTemperature2mMax(builder: flatbuffers.Builder, temperature2mMax: int):
    builder.PrependUOffsetTRelativeSlot(50, flatbuffers.number_types.UOffsetTFlags.py_type(temperature2mMax), 0)

def AddTemperature2mMax(builder: flatbuffers.Builder, temperature2mMax: int):
    EnsembleDailyAddTemperature2mMax(builder, temperature2mMax)

def EnsembleDailyAddTemperature2mMean(builder: flatbuffers.Builder, temperature2mMean: int):
    builder.PrependUOffsetTRelativeSlot(51, flatbuffers.number_types.UOffsetTFlags.py_type(temperature2mMean), 0)

def AddTemperature2mMean(builder: flatbuffers.Builder, temperature2mMean: int):
    EnsembleDailyAddTemperature2mMean(builder, temperature2mMean)

def EnsembleDailyAddTemperature2mMin(builder: flatbuffers.Builder, temperature2mMin: int):
    builder.PrependUOffsetTRelativeSlot(52, flatbuffers.number_types.UOffsetTFlags.py_type(temperature2mMin), 0)

def AddTemperature2mMin(builder: flatbuffers.Builder, temperature2mMin: int):
    EnsembleDailyAddTemperature2mMin(builder, temperature2mMin)

def EnsembleDailyAddUpdraftMax(builder: flatbuffers.Builder, updraftMax: int):
    builder.PrependUOffsetTRelativeSlot(53, flatbuffers.number_types.UOffsetTFlags.py_type(updraftMax), 0)

def AddUpdraftMax(builder: flatbuffers.Builder, updraftMax: int):
    EnsembleDailyAddUpdraftMax(builder, updraftMax)

def EnsembleDailyAddUvIndexClearSkyMax(builder: flatbuffers.Builder, uvIndexClearSkyMax: int):
    builder.PrependUOffsetTRelativeSlot(54, flatbuffers.number_types.UOffsetTFlags.py_type(uvIndexClearSkyMax), 0)

def AddUvIndexClearSkyMax(builder: flatbuffers.Builder, uvIndexClearSkyMax: int):
    EnsembleDailyAddUvIndexClearSkyMax(builder, uvIndexClearSkyMax)

def EnsembleDailyAddUvIndexMax(builder: flatbuffers.Builder, uvIndexMax: int):
    builder.PrependUOffsetTRelativeSlot(55, flatbuffers.number_types.UOffsetTFlags.py_type(uvIndexMax), 0)

def AddUvIndexMax(builder: flatbuffers.Builder, uvIndexMax: int):
    EnsembleDailyAddUvIndexMax(builder, uvIndexMax)

def EnsembleDailyAddVaporPressureDeficitMax(builder: flatbuffers.Builder, vaporPressureDeficitMax: int):
    builder.PrependUOffsetTRelativeSlot(56, flatbuffers.number_types.UOffsetTFlags.py_type(vaporPressureDeficitMax), 0)

def AddVaporPressureDeficitMax(builder: flatbuffers.Builder, vaporPressureDeficitMax: int):
    EnsembleDailyAddVaporPressureDeficitMax(builder, vaporPressureDeficitMax)

def EnsembleDailyAddVisibilityMax(builder: flatbuffers.Builder, visibilityMax: int):
    builder.PrependUOffsetTRelativeSlot(57, flatbuffers.number_types.UOffsetTFlags.py_type(visibilityMax), 0)

def AddVisibilityMax(builder: flatbuffers.Builder, visibilityMax: int):
    EnsembleDailyAddVisibilityMax(builder, visibilityMax)

def EnsembleDailyAddVisibilityMean(builder: flatbuffers.Builder, visibilityMean: int):
    builder.PrependUOffsetTRelativeSlot(58, flatbuffers.number_types.UOffsetTFlags.py_type(visibilityMean), 0)

def AddVisibilityMean(builder: flatbuffers.Builder, visibilityMean: int):
    EnsembleDailyAddVisibilityMean(builder, visibilityMean)

def EnsembleDailyAddVisibilityMin(builder: flatbuffers.Builder, visibilityMin: int):
    builder.PrependUOffsetTRelativeSlot(59, flatbuffers.number_types.UOffsetTFlags.py_type(visibilityMin), 0)

def AddVisibilityMin(builder: flatbuffers.Builder, visibilityMin: int):
    EnsembleDailyAddVisibilityMin(builder, visibilityMin)

def EnsembleDailyAddWeathercode(builder: flatbuffers.Builder, weathercode: int):
    builder.PrependUOffsetTRelativeSlot(60, flatbuffers.number_types.UOffsetTFlags.py_type(weathercode), 0)

def AddWeathercode(builder: flatbuffers.Builder, weathercode: int):
    EnsembleDailyAddWeathercode(builder, weathercode)

def EnsembleDailyAddWinddirection10mDominant(builder: flatbuffers.Builder, winddirection10mDominant: int):
    builder.PrependUOffsetTRelativeSlot(61, flatbuffers.number_types.UOffsetTFlags.py_type(winddirection10mDominant), 0)

def AddWinddirection10mDominant(builder: flatbuffers.Builder, winddirection10mDominant: int):
    EnsembleDailyAddWinddirection10mDominant(builder, winddirection10mDominant)

def EnsembleDailyAddWindgusts10mMax(builder: flatbuffers.Builder, windgusts10mMax: int):
    builder.PrependUOffsetTRelativeSlot(62, flatbuffers.number_types.UOffsetTFlags.py_type(windgusts10mMax), 0)

def AddWindgusts10mMax(builder: flatbuffers.Builder, windgusts10mMax: int):
    EnsembleDailyAddWindgusts10mMax(builder, windgusts10mMax)

def EnsembleDailyAddWindgusts10mMean(builder: flatbuffers.Builder, windgusts10mMean: int):
    builder.PrependUOffsetTRelativeSlot(63, flatbuffers.number_types.UOffsetTFlags.py_type(windgusts10mMean), 0)

def AddWindgusts10mMean(builder: flatbuffers.Builder, windgusts10mMean: int):
    EnsembleDailyAddWindgusts10mMean(builder, windgusts10mMean)

def EnsembleDailyAddWindgusts10mMin(builder: flatbuffers.Builder, windgusts10mMin: int):
    builder.PrependUOffsetTRelativeSlot(64, flatbuffers.number_types.UOffsetTFlags.py_type(windgusts10mMin), 0)

def AddWindgusts10mMin(builder: flatbuffers.Builder, windgusts10mMin: int):
    EnsembleDailyAddWindgusts10mMin(builder, windgusts10mMin)

def EnsembleDailyAddWindspeed10mMax(builder: flatbuffers.Builder, windspeed10mMax: int):
    builder.PrependUOffsetTRelativeSlot(65, flatbuffers.number_types.UOffsetTFlags.py_type(windspeed10mMax), 0)

def AddWindspeed10mMax(builder: flatbuffers.Builder, windspeed10mMax: int):
    EnsembleDailyAddWindspeed10mMax(builder, windspeed10mMax)

def EnsembleDailyAddWindspeed10mMean(builder: flatbuffers.Builder, windspeed10mMean: int):
    builder.PrependUOffsetTRelativeSlot(66, flatbuffers.number_types.UOffsetTFlags.py_type(windspeed10mMean), 0)

def AddWindspeed10mMean(builder: flatbuffers.Builder, windspeed10mMean: int):
    EnsembleDailyAddWindspeed10mMean(builder, windspeed10mMean)

def EnsembleDailyAddWindspeed10mMin(builder: flatbuffers.Builder, windspeed10mMin: int):
    builder.PrependUOffsetTRelativeSlot(67, flatbuffers.number_types.UOffsetTFlags.py_type(windspeed10mMin), 0)

def AddWindspeed10mMin(builder: flatbuffers.Builder, windspeed10mMin: int):
    EnsembleDailyAddWindspeed10mMin(builder, windspeed10mMin)

def EnsembleDailyEnd(builder: flatbuffers.Builder) -> int:
    return builder.EndObject()

def End(builder: flatbuffers.Builder) -> int:
    return EnsembleDailyEnd(builder)
