# 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.ValuesAndUnit import ValuesAndUnit
from typing import Optional
np = import_numpy()

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

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

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

    # WeatherDaily
    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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    # WeatherDaily
    def Sunrise(self, j: int):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(98))
        if o != 0:
            a = self._tab.Vector(o)
            return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
        return 0

    # WeatherDaily
    def SunriseAsNumpy(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(98))
        if o != 0:
            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o)
        return 0

    # WeatherDaily
    def SunriseLength(self) -> int:
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(98))
        if o != 0:
            return self._tab.VectorLen(o)
        return 0

    # WeatherDaily
    def SunriseIsNone(self) -> bool:
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(98))
        return o == 0

    # WeatherDaily
    def Sunset(self, j: int):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(100))
        if o != 0:
            a = self._tab.Vector(o)
            return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
        return 0

    # WeatherDaily
    def SunsetAsNumpy(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(100))
        if o != 0:
            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o)
        return 0

    # WeatherDaily
    def SunsetLength(self) -> int:
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(100))
        if o != 0:
            return self._tab.VectorLen(o)
        return 0

    # WeatherDaily
    def SunsetIsNone(self) -> bool:
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(100))
        return o == 0

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def WeatherDailyStart(builder: flatbuffers.Builder):
    builder.StartObject(73)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def AddSunrise(builder: flatbuffers.Builder, sunrise: int):
    WeatherDailyAddSunrise(builder, sunrise)

def WeatherDailyStartSunriseVector(builder, numElems: int) -> int:
    return builder.StartVector(8, numElems, 8)

def StartSunriseVector(builder, numElems: int) -> int:
    return WeatherDailyStartSunriseVector(builder, numElems)

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

def AddSunset(builder: flatbuffers.Builder, sunset: int):
    WeatherDailyAddSunset(builder, sunset)

def WeatherDailyStartSunsetVector(builder, numElems: int) -> int:
    return builder.StartVector(8, numElems, 8)

def StartSunsetVector(builder, numElems: int) -> int:
    return WeatherDailyStartSunsetVector(builder, numElems)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def WeatherDailyAddWetBulbTemperature2mMax(builder: flatbuffers.Builder, wetBulbTemperature2mMax: int):
    builder.PrependUOffsetTRelativeSlot(70, flatbuffers.number_types.UOffsetTFlags.py_type(wetBulbTemperature2mMax), 0)

def AddWetBulbTemperature2mMax(builder: flatbuffers.Builder, wetBulbTemperature2mMax: int):
    WeatherDailyAddWetBulbTemperature2mMax(builder, wetBulbTemperature2mMax)

def WeatherDailyAddWetBulbTemperature2mMean(builder: flatbuffers.Builder, wetBulbTemperature2mMean: int):
    builder.PrependUOffsetTRelativeSlot(71, flatbuffers.number_types.UOffsetTFlags.py_type(wetBulbTemperature2mMean), 0)

def AddWetBulbTemperature2mMean(builder: flatbuffers.Builder, wetBulbTemperature2mMean: int):
    WeatherDailyAddWetBulbTemperature2mMean(builder, wetBulbTemperature2mMean)

def WeatherDailyAddWetBulbTemperature2mMin(builder: flatbuffers.Builder, wetBulbTemperature2mMin: int):
    builder.PrependUOffsetTRelativeSlot(72, flatbuffers.number_types.UOffsetTFlags.py_type(wetBulbTemperature2mMin), 0)

def AddWetBulbTemperature2mMin(builder: flatbuffers.Builder, wetBulbTemperature2mMin: int):
    WeatherDailyAddWetBulbTemperature2mMin(builder, wetBulbTemperature2mMin)

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

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