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

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

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

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

    # WeatherCurrent
    def Time(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos)
        return 0

    # WeatherCurrent
    def Interval(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
        return 0

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def WeatherCurrentStart(builder: flatbuffers.Builder):
    builder.StartObject(114)

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

def WeatherCurrentAddTime(builder: flatbuffers.Builder, time: int):
    builder.PrependInt64Slot(0, time, 0)

def AddTime(builder: flatbuffers.Builder, time: int):
    WeatherCurrentAddTime(builder, time)

def WeatherCurrentAddInterval(builder: flatbuffers.Builder, interval: int):
    builder.PrependInt32Slot(1, interval, 0)

def AddInterval(builder: flatbuffers.Builder, interval: int):
    WeatherCurrentAddInterval(builder, interval)

def WeatherCurrentAddApparentTemperature(builder: flatbuffers.Builder, apparentTemperature: Any):
    builder.PrependStructSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(apparentTemperature), 0)

def AddApparentTemperature(builder: flatbuffers.Builder, apparentTemperature: Any):
    WeatherCurrentAddApparentTemperature(builder, apparentTemperature)

def WeatherCurrentAddCape(builder: flatbuffers.Builder, cape: Any):
    builder.PrependStructSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(cape), 0)

def AddCape(builder: flatbuffers.Builder, cape: Any):
    WeatherCurrentAddCape(builder, cape)

def WeatherCurrentAddCloudcover(builder: flatbuffers.Builder, cloudcover: Any):
    builder.PrependStructSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(cloudcover), 0)

def AddCloudcover(builder: flatbuffers.Builder, cloudcover: Any):
    WeatherCurrentAddCloudcover(builder, cloudcover)

def WeatherCurrentAddCloudcoverHigh(builder: flatbuffers.Builder, cloudcoverHigh: Any):
    builder.PrependStructSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(cloudcoverHigh), 0)

def AddCloudcoverHigh(builder: flatbuffers.Builder, cloudcoverHigh: Any):
    WeatherCurrentAddCloudcoverHigh(builder, cloudcoverHigh)

def WeatherCurrentAddCloudcoverLow(builder: flatbuffers.Builder, cloudcoverLow: Any):
    builder.PrependStructSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(cloudcoverLow), 0)

def AddCloudcoverLow(builder: flatbuffers.Builder, cloudcoverLow: Any):
    WeatherCurrentAddCloudcoverLow(builder, cloudcoverLow)

def WeatherCurrentAddCloudcoverMid(builder: flatbuffers.Builder, cloudcoverMid: Any):
    builder.PrependStructSlot(7, flatbuffers.number_types.UOffsetTFlags.py_type(cloudcoverMid), 0)

def AddCloudcoverMid(builder: flatbuffers.Builder, cloudcoverMid: Any):
    WeatherCurrentAddCloudcoverMid(builder, cloudcoverMid)

def WeatherCurrentAddDewpoint2m(builder: flatbuffers.Builder, dewpoint2m: Any):
    builder.PrependStructSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(dewpoint2m), 0)

def AddDewpoint2m(builder: flatbuffers.Builder, dewpoint2m: Any):
    WeatherCurrentAddDewpoint2m(builder, dewpoint2m)

def WeatherCurrentAddDiffuseRadiation(builder: flatbuffers.Builder, diffuseRadiation: Any):
    builder.PrependStructSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(diffuseRadiation), 0)

def AddDiffuseRadiation(builder: flatbuffers.Builder, diffuseRadiation: Any):
    WeatherCurrentAddDiffuseRadiation(builder, diffuseRadiation)

def WeatherCurrentAddDiffuseRadiationInstant(builder: flatbuffers.Builder, diffuseRadiationInstant: Any):
    builder.PrependStructSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(diffuseRadiationInstant), 0)

def AddDiffuseRadiationInstant(builder: flatbuffers.Builder, diffuseRadiationInstant: Any):
    WeatherCurrentAddDiffuseRadiationInstant(builder, diffuseRadiationInstant)

def WeatherCurrentAddDirectNormalIrradiance(builder: flatbuffers.Builder, directNormalIrradiance: Any):
    builder.PrependStructSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(directNormalIrradiance), 0)

def AddDirectNormalIrradiance(builder: flatbuffers.Builder, directNormalIrradiance: Any):
    WeatherCurrentAddDirectNormalIrradiance(builder, directNormalIrradiance)

def WeatherCurrentAddDirectNormalIrradianceInstant(builder: flatbuffers.Builder, directNormalIrradianceInstant: Any):
    builder.PrependStructSlot(12, flatbuffers.number_types.UOffsetTFlags.py_type(directNormalIrradianceInstant), 0)

def AddDirectNormalIrradianceInstant(builder: flatbuffers.Builder, directNormalIrradianceInstant: Any):
    WeatherCurrentAddDirectNormalIrradianceInstant(builder, directNormalIrradianceInstant)

def WeatherCurrentAddDirectRadiation(builder: flatbuffers.Builder, directRadiation: Any):
    builder.PrependStructSlot(13, flatbuffers.number_types.UOffsetTFlags.py_type(directRadiation), 0)

def AddDirectRadiation(builder: flatbuffers.Builder, directRadiation: Any):
    WeatherCurrentAddDirectRadiation(builder, directRadiation)

def WeatherCurrentAddDirectRadiationInstant(builder: flatbuffers.Builder, directRadiationInstant: Any):
    builder.PrependStructSlot(14, flatbuffers.number_types.UOffsetTFlags.py_type(directRadiationInstant), 0)

def AddDirectRadiationInstant(builder: flatbuffers.Builder, directRadiationInstant: Any):
    WeatherCurrentAddDirectRadiationInstant(builder, directRadiationInstant)

def WeatherCurrentAddEt0FaoEvapotranspiration(builder: flatbuffers.Builder, et0FaoEvapotranspiration: Any):
    builder.PrependStructSlot(15, flatbuffers.number_types.UOffsetTFlags.py_type(et0FaoEvapotranspiration), 0)

def AddEt0FaoEvapotranspiration(builder: flatbuffers.Builder, et0FaoEvapotranspiration: Any):
    WeatherCurrentAddEt0FaoEvapotranspiration(builder, et0FaoEvapotranspiration)

def WeatherCurrentAddEvapotranspiration(builder: flatbuffers.Builder, evapotranspiration: Any):
    builder.PrependStructSlot(16, flatbuffers.number_types.UOffsetTFlags.py_type(evapotranspiration), 0)

def AddEvapotranspiration(builder: flatbuffers.Builder, evapotranspiration: Any):
    WeatherCurrentAddEvapotranspiration(builder, evapotranspiration)

def WeatherCurrentAddFreezinglevelHeight(builder: flatbuffers.Builder, freezinglevelHeight: Any):
    builder.PrependStructSlot(17, flatbuffers.number_types.UOffsetTFlags.py_type(freezinglevelHeight), 0)

def AddFreezinglevelHeight(builder: flatbuffers.Builder, freezinglevelHeight: Any):
    WeatherCurrentAddFreezinglevelHeight(builder, freezinglevelHeight)

def WeatherCurrentAddGrowingDegreeDaysBase0Limit50(builder: flatbuffers.Builder, growingDegreeDaysBase0Limit50: Any):
    builder.PrependStructSlot(18, flatbuffers.number_types.UOffsetTFlags.py_type(growingDegreeDaysBase0Limit50), 0)

def AddGrowingDegreeDaysBase0Limit50(builder: flatbuffers.Builder, growingDegreeDaysBase0Limit50: Any):
    WeatherCurrentAddGrowingDegreeDaysBase0Limit50(builder, growingDegreeDaysBase0Limit50)

def WeatherCurrentAddIsDay(builder: flatbuffers.Builder, isDay: Any):
    builder.PrependStructSlot(19, flatbuffers.number_types.UOffsetTFlags.py_type(isDay), 0)

def AddIsDay(builder: flatbuffers.Builder, isDay: Any):
    WeatherCurrentAddIsDay(builder, isDay)

def WeatherCurrentAddLatentHeatflux(builder: flatbuffers.Builder, latentHeatflux: Any):
    builder.PrependStructSlot(20, flatbuffers.number_types.UOffsetTFlags.py_type(latentHeatflux), 0)

def AddLatentHeatflux(builder: flatbuffers.Builder, latentHeatflux: Any):
    WeatherCurrentAddLatentHeatflux(builder, latentHeatflux)

def WeatherCurrentAddLeafWetnessProbability(builder: flatbuffers.Builder, leafWetnessProbability: Any):
    builder.PrependStructSlot(21, flatbuffers.number_types.UOffsetTFlags.py_type(leafWetnessProbability), 0)

def AddLeafWetnessProbability(builder: flatbuffers.Builder, leafWetnessProbability: Any):
    WeatherCurrentAddLeafWetnessProbability(builder, leafWetnessProbability)

def WeatherCurrentAddLiftedIndex(builder: flatbuffers.Builder, liftedIndex: Any):
    builder.PrependStructSlot(22, flatbuffers.number_types.UOffsetTFlags.py_type(liftedIndex), 0)

def AddLiftedIndex(builder: flatbuffers.Builder, liftedIndex: Any):
    WeatherCurrentAddLiftedIndex(builder, liftedIndex)

def WeatherCurrentAddLightningPotential(builder: flatbuffers.Builder, lightningPotential: Any):
    builder.PrependStructSlot(23, flatbuffers.number_types.UOffsetTFlags.py_type(lightningPotential), 0)

def AddLightningPotential(builder: flatbuffers.Builder, lightningPotential: Any):
    WeatherCurrentAddLightningPotential(builder, lightningPotential)

def WeatherCurrentAddPrecipitation(builder: flatbuffers.Builder, precipitation: Any):
    builder.PrependStructSlot(24, flatbuffers.number_types.UOffsetTFlags.py_type(precipitation), 0)

def AddPrecipitation(builder: flatbuffers.Builder, precipitation: Any):
    WeatherCurrentAddPrecipitation(builder, precipitation)

def WeatherCurrentAddPrecipitationProbability(builder: flatbuffers.Builder, precipitationProbability: Any):
    builder.PrependStructSlot(25, flatbuffers.number_types.UOffsetTFlags.py_type(precipitationProbability), 0)

def AddPrecipitationProbability(builder: flatbuffers.Builder, precipitationProbability: Any):
    WeatherCurrentAddPrecipitationProbability(builder, precipitationProbability)

def WeatherCurrentAddPressureMsl(builder: flatbuffers.Builder, pressureMsl: Any):
    builder.PrependStructSlot(26, flatbuffers.number_types.UOffsetTFlags.py_type(pressureMsl), 0)

def AddPressureMsl(builder: flatbuffers.Builder, pressureMsl: Any):
    WeatherCurrentAddPressureMsl(builder, pressureMsl)

def WeatherCurrentAddRain(builder: flatbuffers.Builder, rain: Any):
    builder.PrependStructSlot(27, flatbuffers.number_types.UOffsetTFlags.py_type(rain), 0)

def AddRain(builder: flatbuffers.Builder, rain: Any):
    WeatherCurrentAddRain(builder, rain)

def WeatherCurrentAddRelativehumidity2m(builder: flatbuffers.Builder, relativehumidity2m: Any):
    builder.PrependStructSlot(28, flatbuffers.number_types.UOffsetTFlags.py_type(relativehumidity2m), 0)

def AddRelativehumidity2m(builder: flatbuffers.Builder, relativehumidity2m: Any):
    WeatherCurrentAddRelativehumidity2m(builder, relativehumidity2m)

def WeatherCurrentAddRunoff(builder: flatbuffers.Builder, runoff: Any):
    builder.PrependStructSlot(29, flatbuffers.number_types.UOffsetTFlags.py_type(runoff), 0)

def AddRunoff(builder: flatbuffers.Builder, runoff: Any):
    WeatherCurrentAddRunoff(builder, runoff)

def WeatherCurrentAddSensibleHeatflux(builder: flatbuffers.Builder, sensibleHeatflux: Any):
    builder.PrependStructSlot(30, flatbuffers.number_types.UOffsetTFlags.py_type(sensibleHeatflux), 0)

def AddSensibleHeatflux(builder: flatbuffers.Builder, sensibleHeatflux: Any):
    WeatherCurrentAddSensibleHeatflux(builder, sensibleHeatflux)

def WeatherCurrentAddShortwaveRadiation(builder: flatbuffers.Builder, shortwaveRadiation: Any):
    builder.PrependStructSlot(31, flatbuffers.number_types.UOffsetTFlags.py_type(shortwaveRadiation), 0)

def AddShortwaveRadiation(builder: flatbuffers.Builder, shortwaveRadiation: Any):
    WeatherCurrentAddShortwaveRadiation(builder, shortwaveRadiation)

def WeatherCurrentAddShortwaveRadiationInstant(builder: flatbuffers.Builder, shortwaveRadiationInstant: Any):
    builder.PrependStructSlot(32, flatbuffers.number_types.UOffsetTFlags.py_type(shortwaveRadiationInstant), 0)

def AddShortwaveRadiationInstant(builder: flatbuffers.Builder, shortwaveRadiationInstant: Any):
    WeatherCurrentAddShortwaveRadiationInstant(builder, shortwaveRadiationInstant)

def WeatherCurrentAddShowers(builder: flatbuffers.Builder, showers: Any):
    builder.PrependStructSlot(33, flatbuffers.number_types.UOffsetTFlags.py_type(showers), 0)

def AddShowers(builder: flatbuffers.Builder, showers: Any):
    WeatherCurrentAddShowers(builder, showers)

def WeatherCurrentAddSnowDepth(builder: flatbuffers.Builder, snowDepth: Any):
    builder.PrependStructSlot(34, flatbuffers.number_types.UOffsetTFlags.py_type(snowDepth), 0)

def AddSnowDepth(builder: flatbuffers.Builder, snowDepth: Any):
    WeatherCurrentAddSnowDepth(builder, snowDepth)

def WeatherCurrentAddSnowHeight(builder: flatbuffers.Builder, snowHeight: Any):
    builder.PrependStructSlot(35, flatbuffers.number_types.UOffsetTFlags.py_type(snowHeight), 0)

def AddSnowHeight(builder: flatbuffers.Builder, snowHeight: Any):
    WeatherCurrentAddSnowHeight(builder, snowHeight)

def WeatherCurrentAddSnowfall(builder: flatbuffers.Builder, snowfall: Any):
    builder.PrependStructSlot(36, flatbuffers.number_types.UOffsetTFlags.py_type(snowfall), 0)

def AddSnowfall(builder: flatbuffers.Builder, snowfall: Any):
    WeatherCurrentAddSnowfall(builder, snowfall)

def WeatherCurrentAddSnowfallHeight(builder: flatbuffers.Builder, snowfallHeight: Any):
    builder.PrependStructSlot(37, flatbuffers.number_types.UOffsetTFlags.py_type(snowfallHeight), 0)

def AddSnowfallHeight(builder: flatbuffers.Builder, snowfallHeight: Any):
    WeatherCurrentAddSnowfallHeight(builder, snowfallHeight)

def WeatherCurrentAddSnowfallWaterEquivalent(builder: flatbuffers.Builder, snowfallWaterEquivalent: Any):
    builder.PrependStructSlot(38, flatbuffers.number_types.UOffsetTFlags.py_type(snowfallWaterEquivalent), 0)

def AddSnowfallWaterEquivalent(builder: flatbuffers.Builder, snowfallWaterEquivalent: Any):
    WeatherCurrentAddSnowfallWaterEquivalent(builder, snowfallWaterEquivalent)

def WeatherCurrentAddSoilMoisture0To1cm(builder: flatbuffers.Builder, soilMoisture0To1cm: Any):
    builder.PrependStructSlot(39, flatbuffers.number_types.UOffsetTFlags.py_type(soilMoisture0To1cm), 0)

def AddSoilMoisture0To1cm(builder: flatbuffers.Builder, soilMoisture0To1cm: Any):
    WeatherCurrentAddSoilMoisture0To1cm(builder, soilMoisture0To1cm)

def WeatherCurrentAddSoilMoisture0To100cm(builder: flatbuffers.Builder, soilMoisture0To100cm: Any):
    builder.PrependStructSlot(40, flatbuffers.number_types.UOffsetTFlags.py_type(soilMoisture0To100cm), 0)

def AddSoilMoisture0To100cm(builder: flatbuffers.Builder, soilMoisture0To100cm: Any):
    WeatherCurrentAddSoilMoisture0To100cm(builder, soilMoisture0To100cm)

def WeatherCurrentAddSoilMoisture0To10cm(builder: flatbuffers.Builder, soilMoisture0To10cm: Any):
    builder.PrependStructSlot(41, flatbuffers.number_types.UOffsetTFlags.py_type(soilMoisture0To10cm), 0)

def AddSoilMoisture0To10cm(builder: flatbuffers.Builder, soilMoisture0To10cm: Any):
    WeatherCurrentAddSoilMoisture0To10cm(builder, soilMoisture0To10cm)

def WeatherCurrentAddSoilMoisture0To7cm(builder: flatbuffers.Builder, soilMoisture0To7cm: Any):
    builder.PrependStructSlot(42, flatbuffers.number_types.UOffsetTFlags.py_type(soilMoisture0To7cm), 0)

def AddSoilMoisture0To7cm(builder: flatbuffers.Builder, soilMoisture0To7cm: Any):
    WeatherCurrentAddSoilMoisture0To7cm(builder, soilMoisture0To7cm)

def WeatherCurrentAddSoilMoisture100To200cm(builder: flatbuffers.Builder, soilMoisture100To200cm: Any):
    builder.PrependStructSlot(43, flatbuffers.number_types.UOffsetTFlags.py_type(soilMoisture100To200cm), 0)

def AddSoilMoisture100To200cm(builder: flatbuffers.Builder, soilMoisture100To200cm: Any):
    WeatherCurrentAddSoilMoisture100To200cm(builder, soilMoisture100To200cm)

def WeatherCurrentAddSoilMoisture100To255cm(builder: flatbuffers.Builder, soilMoisture100To255cm: Any):
    builder.PrependStructSlot(44, flatbuffers.number_types.UOffsetTFlags.py_type(soilMoisture100To255cm), 0)

def AddSoilMoisture100To255cm(builder: flatbuffers.Builder, soilMoisture100To255cm: Any):
    WeatherCurrentAddSoilMoisture100To255cm(builder, soilMoisture100To255cm)

def WeatherCurrentAddSoilMoisture10To40cm(builder: flatbuffers.Builder, soilMoisture10To40cm: Any):
    builder.PrependStructSlot(45, flatbuffers.number_types.UOffsetTFlags.py_type(soilMoisture10To40cm), 0)

def AddSoilMoisture10To40cm(builder: flatbuffers.Builder, soilMoisture10To40cm: Any):
    WeatherCurrentAddSoilMoisture10To40cm(builder, soilMoisture10To40cm)

def WeatherCurrentAddSoilMoisture1To3cm(builder: flatbuffers.Builder, soilMoisture1To3cm: Any):
    builder.PrependStructSlot(46, flatbuffers.number_types.UOffsetTFlags.py_type(soilMoisture1To3cm), 0)

def AddSoilMoisture1To3cm(builder: flatbuffers.Builder, soilMoisture1To3cm: Any):
    WeatherCurrentAddSoilMoisture1To3cm(builder, soilMoisture1To3cm)

def WeatherCurrentAddSoilMoisture27To81cm(builder: flatbuffers.Builder, soilMoisture27To81cm: Any):
    builder.PrependStructSlot(47, flatbuffers.number_types.UOffsetTFlags.py_type(soilMoisture27To81cm), 0)

def AddSoilMoisture27To81cm(builder: flatbuffers.Builder, soilMoisture27To81cm: Any):
    WeatherCurrentAddSoilMoisture27To81cm(builder, soilMoisture27To81cm)

def WeatherCurrentAddSoilMoisture28To100cm(builder: flatbuffers.Builder, soilMoisture28To100cm: Any):
    builder.PrependStructSlot(48, flatbuffers.number_types.UOffsetTFlags.py_type(soilMoisture28To100cm), 0)

def AddSoilMoisture28To100cm(builder: flatbuffers.Builder, soilMoisture28To100cm: Any):
    WeatherCurrentAddSoilMoisture28To100cm(builder, soilMoisture28To100cm)

def WeatherCurrentAddSoilMoisture3To9cm(builder: flatbuffers.Builder, soilMoisture3To9cm: Any):
    builder.PrependStructSlot(49, flatbuffers.number_types.UOffsetTFlags.py_type(soilMoisture3To9cm), 0)

def AddSoilMoisture3To9cm(builder: flatbuffers.Builder, soilMoisture3To9cm: Any):
    WeatherCurrentAddSoilMoisture3To9cm(builder, soilMoisture3To9cm)

def WeatherCurrentAddSoilMoisture40To100cm(builder: flatbuffers.Builder, soilMoisture40To100cm: Any):
    builder.PrependStructSlot(50, flatbuffers.number_types.UOffsetTFlags.py_type(soilMoisture40To100cm), 0)

def AddSoilMoisture40To100cm(builder: flatbuffers.Builder, soilMoisture40To100cm: Any):
    WeatherCurrentAddSoilMoisture40To100cm(builder, soilMoisture40To100cm)

def WeatherCurrentAddSoilMoisture7To28cm(builder: flatbuffers.Builder, soilMoisture7To28cm: Any):
    builder.PrependStructSlot(51, flatbuffers.number_types.UOffsetTFlags.py_type(soilMoisture7To28cm), 0)

def AddSoilMoisture7To28cm(builder: flatbuffers.Builder, soilMoisture7To28cm: Any):
    WeatherCurrentAddSoilMoisture7To28cm(builder, soilMoisture7To28cm)

def WeatherCurrentAddSoilMoisture9To27cm(builder: flatbuffers.Builder, soilMoisture9To27cm: Any):
    builder.PrependStructSlot(52, flatbuffers.number_types.UOffsetTFlags.py_type(soilMoisture9To27cm), 0)

def AddSoilMoisture9To27cm(builder: flatbuffers.Builder, soilMoisture9To27cm: Any):
    WeatherCurrentAddSoilMoisture9To27cm(builder, soilMoisture9To27cm)

def WeatherCurrentAddSoilMoistureIndex0To100cm(builder: flatbuffers.Builder, soilMoistureIndex0To100cm: Any):
    builder.PrependStructSlot(53, flatbuffers.number_types.UOffsetTFlags.py_type(soilMoistureIndex0To100cm), 0)

def AddSoilMoistureIndex0To100cm(builder: flatbuffers.Builder, soilMoistureIndex0To100cm: Any):
    WeatherCurrentAddSoilMoistureIndex0To100cm(builder, soilMoistureIndex0To100cm)

def WeatherCurrentAddSoilMoistureIndex0To7cm(builder: flatbuffers.Builder, soilMoistureIndex0To7cm: Any):
    builder.PrependStructSlot(54, flatbuffers.number_types.UOffsetTFlags.py_type(soilMoistureIndex0To7cm), 0)

def AddSoilMoistureIndex0To7cm(builder: flatbuffers.Builder, soilMoistureIndex0To7cm: Any):
    WeatherCurrentAddSoilMoistureIndex0To7cm(builder, soilMoistureIndex0To7cm)

def WeatherCurrentAddSoilMoistureIndex100To255cm(builder: flatbuffers.Builder, soilMoistureIndex100To255cm: Any):
    builder.PrependStructSlot(55, flatbuffers.number_types.UOffsetTFlags.py_type(soilMoistureIndex100To255cm), 0)

def AddSoilMoistureIndex100To255cm(builder: flatbuffers.Builder, soilMoistureIndex100To255cm: Any):
    WeatherCurrentAddSoilMoistureIndex100To255cm(builder, soilMoistureIndex100To255cm)

def WeatherCurrentAddSoilMoistureIndex28To100cm(builder: flatbuffers.Builder, soilMoistureIndex28To100cm: Any):
    builder.PrependStructSlot(56, flatbuffers.number_types.UOffsetTFlags.py_type(soilMoistureIndex28To100cm), 0)

def AddSoilMoistureIndex28To100cm(builder: flatbuffers.Builder, soilMoistureIndex28To100cm: Any):
    WeatherCurrentAddSoilMoistureIndex28To100cm(builder, soilMoistureIndex28To100cm)

def WeatherCurrentAddSoilMoistureIndex7To28cm(builder: flatbuffers.Builder, soilMoistureIndex7To28cm: Any):
    builder.PrependStructSlot(57, flatbuffers.number_types.UOffsetTFlags.py_type(soilMoistureIndex7To28cm), 0)

def AddSoilMoistureIndex7To28cm(builder: flatbuffers.Builder, soilMoistureIndex7To28cm: Any):
    WeatherCurrentAddSoilMoistureIndex7To28cm(builder, soilMoistureIndex7To28cm)

def WeatherCurrentAddSoilTemperature0To100cm(builder: flatbuffers.Builder, soilTemperature0To100cm: Any):
    builder.PrependStructSlot(58, flatbuffers.number_types.UOffsetTFlags.py_type(soilTemperature0To100cm), 0)

def AddSoilTemperature0To100cm(builder: flatbuffers.Builder, soilTemperature0To100cm: Any):
    WeatherCurrentAddSoilTemperature0To100cm(builder, soilTemperature0To100cm)

def WeatherCurrentAddSoilTemperature0To10cm(builder: flatbuffers.Builder, soilTemperature0To10cm: Any):
    builder.PrependStructSlot(59, flatbuffers.number_types.UOffsetTFlags.py_type(soilTemperature0To10cm), 0)

def AddSoilTemperature0To10cm(builder: flatbuffers.Builder, soilTemperature0To10cm: Any):
    WeatherCurrentAddSoilTemperature0To10cm(builder, soilTemperature0To10cm)

def WeatherCurrentAddSoilTemperature0To7cm(builder: flatbuffers.Builder, soilTemperature0To7cm: Any):
    builder.PrependStructSlot(60, flatbuffers.number_types.UOffsetTFlags.py_type(soilTemperature0To7cm), 0)

def AddSoilTemperature0To7cm(builder: flatbuffers.Builder, soilTemperature0To7cm: Any):
    WeatherCurrentAddSoilTemperature0To7cm(builder, soilTemperature0To7cm)

def WeatherCurrentAddSoilTemperature0cm(builder: flatbuffers.Builder, soilTemperature0cm: Any):
    builder.PrependStructSlot(61, flatbuffers.number_types.UOffsetTFlags.py_type(soilTemperature0cm), 0)

def AddSoilTemperature0cm(builder: flatbuffers.Builder, soilTemperature0cm: Any):
    WeatherCurrentAddSoilTemperature0cm(builder, soilTemperature0cm)

def WeatherCurrentAddSoilTemperature100To200cm(builder: flatbuffers.Builder, soilTemperature100To200cm: Any):
    builder.PrependStructSlot(62, flatbuffers.number_types.UOffsetTFlags.py_type(soilTemperature100To200cm), 0)

def AddSoilTemperature100To200cm(builder: flatbuffers.Builder, soilTemperature100To200cm: Any):
    WeatherCurrentAddSoilTemperature100To200cm(builder, soilTemperature100To200cm)

def WeatherCurrentAddSoilTemperature100To255cm(builder: flatbuffers.Builder, soilTemperature100To255cm: Any):
    builder.PrependStructSlot(63, flatbuffers.number_types.UOffsetTFlags.py_type(soilTemperature100To255cm), 0)

def AddSoilTemperature100To255cm(builder: flatbuffers.Builder, soilTemperature100To255cm: Any):
    WeatherCurrentAddSoilTemperature100To255cm(builder, soilTemperature100To255cm)

def WeatherCurrentAddSoilTemperature10To40cm(builder: flatbuffers.Builder, soilTemperature10To40cm: Any):
    builder.PrependStructSlot(64, flatbuffers.number_types.UOffsetTFlags.py_type(soilTemperature10To40cm), 0)

def AddSoilTemperature10To40cm(builder: flatbuffers.Builder, soilTemperature10To40cm: Any):
    WeatherCurrentAddSoilTemperature10To40cm(builder, soilTemperature10To40cm)

def WeatherCurrentAddSoilTemperature18cm(builder: flatbuffers.Builder, soilTemperature18cm: Any):
    builder.PrependStructSlot(65, flatbuffers.number_types.UOffsetTFlags.py_type(soilTemperature18cm), 0)

def AddSoilTemperature18cm(builder: flatbuffers.Builder, soilTemperature18cm: Any):
    WeatherCurrentAddSoilTemperature18cm(builder, soilTemperature18cm)

def WeatherCurrentAddSoilTemperature28To100cm(builder: flatbuffers.Builder, soilTemperature28To100cm: Any):
    builder.PrependStructSlot(66, flatbuffers.number_types.UOffsetTFlags.py_type(soilTemperature28To100cm), 0)

def AddSoilTemperature28To100cm(builder: flatbuffers.Builder, soilTemperature28To100cm: Any):
    WeatherCurrentAddSoilTemperature28To100cm(builder, soilTemperature28To100cm)

def WeatherCurrentAddSoilTemperature40To100cm(builder: flatbuffers.Builder, soilTemperature40To100cm: Any):
    builder.PrependStructSlot(67, flatbuffers.number_types.UOffsetTFlags.py_type(soilTemperature40To100cm), 0)

def AddSoilTemperature40To100cm(builder: flatbuffers.Builder, soilTemperature40To100cm: Any):
    WeatherCurrentAddSoilTemperature40To100cm(builder, soilTemperature40To100cm)

def WeatherCurrentAddSoilTemperature54cm(builder: flatbuffers.Builder, soilTemperature54cm: Any):
    builder.PrependStructSlot(68, flatbuffers.number_types.UOffsetTFlags.py_type(soilTemperature54cm), 0)

def AddSoilTemperature54cm(builder: flatbuffers.Builder, soilTemperature54cm: Any):
    WeatherCurrentAddSoilTemperature54cm(builder, soilTemperature54cm)

def WeatherCurrentAddSoilTemperature6cm(builder: flatbuffers.Builder, soilTemperature6cm: Any):
    builder.PrependStructSlot(69, flatbuffers.number_types.UOffsetTFlags.py_type(soilTemperature6cm), 0)

def AddSoilTemperature6cm(builder: flatbuffers.Builder, soilTemperature6cm: Any):
    WeatherCurrentAddSoilTemperature6cm(builder, soilTemperature6cm)

def WeatherCurrentAddSoilTemperature7To28cm(builder: flatbuffers.Builder, soilTemperature7To28cm: Any):
    builder.PrependStructSlot(70, flatbuffers.number_types.UOffsetTFlags.py_type(soilTemperature7To28cm), 0)

def AddSoilTemperature7To28cm(builder: flatbuffers.Builder, soilTemperature7To28cm: Any):
    WeatherCurrentAddSoilTemperature7To28cm(builder, soilTemperature7To28cm)

def WeatherCurrentAddSurfacePressure(builder: flatbuffers.Builder, surfacePressure: Any):
    builder.PrependStructSlot(71, flatbuffers.number_types.UOffsetTFlags.py_type(surfacePressure), 0)

def AddSurfacePressure(builder: flatbuffers.Builder, surfacePressure: Any):
    WeatherCurrentAddSurfacePressure(builder, surfacePressure)

def WeatherCurrentAddSurfaceTemperature(builder: flatbuffers.Builder, surfaceTemperature: Any):
    builder.PrependStructSlot(72, flatbuffers.number_types.UOffsetTFlags.py_type(surfaceTemperature), 0)

def AddSurfaceTemperature(builder: flatbuffers.Builder, surfaceTemperature: Any):
    WeatherCurrentAddSurfaceTemperature(builder, surfaceTemperature)

def WeatherCurrentAddTemperature100m(builder: flatbuffers.Builder, temperature100m: Any):
    builder.PrependStructSlot(73, flatbuffers.number_types.UOffsetTFlags.py_type(temperature100m), 0)

def AddTemperature100m(builder: flatbuffers.Builder, temperature100m: Any):
    WeatherCurrentAddTemperature100m(builder, temperature100m)

def WeatherCurrentAddTemperature120m(builder: flatbuffers.Builder, temperature120m: Any):
    builder.PrependStructSlot(74, flatbuffers.number_types.UOffsetTFlags.py_type(temperature120m), 0)

def AddTemperature120m(builder: flatbuffers.Builder, temperature120m: Any):
    WeatherCurrentAddTemperature120m(builder, temperature120m)

def WeatherCurrentAddTemperature150m(builder: flatbuffers.Builder, temperature150m: Any):
    builder.PrependStructSlot(75, flatbuffers.number_types.UOffsetTFlags.py_type(temperature150m), 0)

def AddTemperature150m(builder: flatbuffers.Builder, temperature150m: Any):
    WeatherCurrentAddTemperature150m(builder, temperature150m)

def WeatherCurrentAddTemperature180m(builder: flatbuffers.Builder, temperature180m: Any):
    builder.PrependStructSlot(76, flatbuffers.number_types.UOffsetTFlags.py_type(temperature180m), 0)

def AddTemperature180m(builder: flatbuffers.Builder, temperature180m: Any):
    WeatherCurrentAddTemperature180m(builder, temperature180m)

def WeatherCurrentAddTemperature2m(builder: flatbuffers.Builder, temperature2m: Any):
    builder.PrependStructSlot(77, flatbuffers.number_types.UOffsetTFlags.py_type(temperature2m), 0)

def AddTemperature2m(builder: flatbuffers.Builder, temperature2m: Any):
    WeatherCurrentAddTemperature2m(builder, temperature2m)

def WeatherCurrentAddTemperature20m(builder: flatbuffers.Builder, temperature20m: Any):
    builder.PrependStructSlot(78, flatbuffers.number_types.UOffsetTFlags.py_type(temperature20m), 0)

def AddTemperature20m(builder: flatbuffers.Builder, temperature20m: Any):
    WeatherCurrentAddTemperature20m(builder, temperature20m)

def WeatherCurrentAddTemperature200m(builder: flatbuffers.Builder, temperature200m: Any):
    builder.PrependStructSlot(79, flatbuffers.number_types.UOffsetTFlags.py_type(temperature200m), 0)

def AddTemperature200m(builder: flatbuffers.Builder, temperature200m: Any):
    WeatherCurrentAddTemperature200m(builder, temperature200m)

def WeatherCurrentAddTemperature50m(builder: flatbuffers.Builder, temperature50m: Any):
    builder.PrependStructSlot(80, flatbuffers.number_types.UOffsetTFlags.py_type(temperature50m), 0)

def AddTemperature50m(builder: flatbuffers.Builder, temperature50m: Any):
    WeatherCurrentAddTemperature50m(builder, temperature50m)

def WeatherCurrentAddTemperature40m(builder: flatbuffers.Builder, temperature40m: Any):
    builder.PrependStructSlot(81, flatbuffers.number_types.UOffsetTFlags.py_type(temperature40m), 0)

def AddTemperature40m(builder: flatbuffers.Builder, temperature40m: Any):
    WeatherCurrentAddTemperature40m(builder, temperature40m)

def WeatherCurrentAddTemperature80m(builder: flatbuffers.Builder, temperature80m: Any):
    builder.PrependStructSlot(82, flatbuffers.number_types.UOffsetTFlags.py_type(temperature80m), 0)

def AddTemperature80m(builder: flatbuffers.Builder, temperature80m: Any):
    WeatherCurrentAddTemperature80m(builder, temperature80m)

def WeatherCurrentAddTerrestrialRadiation(builder: flatbuffers.Builder, terrestrialRadiation: Any):
    builder.PrependStructSlot(83, flatbuffers.number_types.UOffsetTFlags.py_type(terrestrialRadiation), 0)

def AddTerrestrialRadiation(builder: flatbuffers.Builder, terrestrialRadiation: Any):
    WeatherCurrentAddTerrestrialRadiation(builder, terrestrialRadiation)

def WeatherCurrentAddTerrestrialRadiationInstant(builder: flatbuffers.Builder, terrestrialRadiationInstant: Any):
    builder.PrependStructSlot(84, flatbuffers.number_types.UOffsetTFlags.py_type(terrestrialRadiationInstant), 0)

def AddTerrestrialRadiationInstant(builder: flatbuffers.Builder, terrestrialRadiationInstant: Any):
    WeatherCurrentAddTerrestrialRadiationInstant(builder, terrestrialRadiationInstant)

def WeatherCurrentAddTotalColumnIntegratedWaterVapour(builder: flatbuffers.Builder, totalColumnIntegratedWaterVapour: Any):
    builder.PrependStructSlot(85, flatbuffers.number_types.UOffsetTFlags.py_type(totalColumnIntegratedWaterVapour), 0)

def AddTotalColumnIntegratedWaterVapour(builder: flatbuffers.Builder, totalColumnIntegratedWaterVapour: Any):
    WeatherCurrentAddTotalColumnIntegratedWaterVapour(builder, totalColumnIntegratedWaterVapour)

def WeatherCurrentAddUpdraft(builder: flatbuffers.Builder, updraft: Any):
    builder.PrependStructSlot(86, flatbuffers.number_types.UOffsetTFlags.py_type(updraft), 0)

def AddUpdraft(builder: flatbuffers.Builder, updraft: Any):
    WeatherCurrentAddUpdraft(builder, updraft)

def WeatherCurrentAddUvIndex(builder: flatbuffers.Builder, uvIndex: Any):
    builder.PrependStructSlot(87, flatbuffers.number_types.UOffsetTFlags.py_type(uvIndex), 0)

def AddUvIndex(builder: flatbuffers.Builder, uvIndex: Any):
    WeatherCurrentAddUvIndex(builder, uvIndex)

def WeatherCurrentAddUvIndexClearSky(builder: flatbuffers.Builder, uvIndexClearSky: Any):
    builder.PrependStructSlot(88, flatbuffers.number_types.UOffsetTFlags.py_type(uvIndexClearSky), 0)

def AddUvIndexClearSky(builder: flatbuffers.Builder, uvIndexClearSky: Any):
    WeatherCurrentAddUvIndexClearSky(builder, uvIndexClearSky)

def WeatherCurrentAddVaporPressureDeficit(builder: flatbuffers.Builder, vaporPressureDeficit: Any):
    builder.PrependStructSlot(89, flatbuffers.number_types.UOffsetTFlags.py_type(vaporPressureDeficit), 0)

def AddVaporPressureDeficit(builder: flatbuffers.Builder, vaporPressureDeficit: Any):
    WeatherCurrentAddVaporPressureDeficit(builder, vaporPressureDeficit)

def WeatherCurrentAddVisibility(builder: flatbuffers.Builder, visibility: Any):
    builder.PrependStructSlot(90, flatbuffers.number_types.UOffsetTFlags.py_type(visibility), 0)

def AddVisibility(builder: flatbuffers.Builder, visibility: Any):
    WeatherCurrentAddVisibility(builder, visibility)

def WeatherCurrentAddWeathercode(builder: flatbuffers.Builder, weathercode: Any):
    builder.PrependStructSlot(91, flatbuffers.number_types.UOffsetTFlags.py_type(weathercode), 0)

def AddWeathercode(builder: flatbuffers.Builder, weathercode: Any):
    WeatherCurrentAddWeathercode(builder, weathercode)

def WeatherCurrentAddWinddirection100m(builder: flatbuffers.Builder, winddirection100m: Any):
    builder.PrependStructSlot(92, flatbuffers.number_types.UOffsetTFlags.py_type(winddirection100m), 0)

def AddWinddirection100m(builder: flatbuffers.Builder, winddirection100m: Any):
    WeatherCurrentAddWinddirection100m(builder, winddirection100m)

def WeatherCurrentAddWinddirection10m(builder: flatbuffers.Builder, winddirection10m: Any):
    builder.PrependStructSlot(93, flatbuffers.number_types.UOffsetTFlags.py_type(winddirection10m), 0)

def AddWinddirection10m(builder: flatbuffers.Builder, winddirection10m: Any):
    WeatherCurrentAddWinddirection10m(builder, winddirection10m)

def WeatherCurrentAddWinddirection120m(builder: flatbuffers.Builder, winddirection120m: Any):
    builder.PrependStructSlot(94, flatbuffers.number_types.UOffsetTFlags.py_type(winddirection120m), 0)

def AddWinddirection120m(builder: flatbuffers.Builder, winddirection120m: Any):
    WeatherCurrentAddWinddirection120m(builder, winddirection120m)

def WeatherCurrentAddWinddirection150m(builder: flatbuffers.Builder, winddirection150m: Any):
    builder.PrependStructSlot(95, flatbuffers.number_types.UOffsetTFlags.py_type(winddirection150m), 0)

def AddWinddirection150m(builder: flatbuffers.Builder, winddirection150m: Any):
    WeatherCurrentAddWinddirection150m(builder, winddirection150m)

def WeatherCurrentAddWinddirection180m(builder: flatbuffers.Builder, winddirection180m: Any):
    builder.PrependStructSlot(96, flatbuffers.number_types.UOffsetTFlags.py_type(winddirection180m), 0)

def AddWinddirection180m(builder: flatbuffers.Builder, winddirection180m: Any):
    WeatherCurrentAddWinddirection180m(builder, winddirection180m)

def WeatherCurrentAddWinddirection200m(builder: flatbuffers.Builder, winddirection200m: Any):
    builder.PrependStructSlot(97, flatbuffers.number_types.UOffsetTFlags.py_type(winddirection200m), 0)

def AddWinddirection200m(builder: flatbuffers.Builder, winddirection200m: Any):
    WeatherCurrentAddWinddirection200m(builder, winddirection200m)

def WeatherCurrentAddWinddirection20m(builder: flatbuffers.Builder, winddirection20m: Any):
    builder.PrependStructSlot(98, flatbuffers.number_types.UOffsetTFlags.py_type(winddirection20m), 0)

def AddWinddirection20m(builder: flatbuffers.Builder, winddirection20m: Any):
    WeatherCurrentAddWinddirection20m(builder, winddirection20m)

def WeatherCurrentAddWinddirection40m(builder: flatbuffers.Builder, winddirection40m: Any):
    builder.PrependStructSlot(99, flatbuffers.number_types.UOffsetTFlags.py_type(winddirection40m), 0)

def AddWinddirection40m(builder: flatbuffers.Builder, winddirection40m: Any):
    WeatherCurrentAddWinddirection40m(builder, winddirection40m)

def WeatherCurrentAddWinddirection50m(builder: flatbuffers.Builder, winddirection50m: Any):
    builder.PrependStructSlot(100, flatbuffers.number_types.UOffsetTFlags.py_type(winddirection50m), 0)

def AddWinddirection50m(builder: flatbuffers.Builder, winddirection50m: Any):
    WeatherCurrentAddWinddirection50m(builder, winddirection50m)

def WeatherCurrentAddWinddirection80m(builder: flatbuffers.Builder, winddirection80m: Any):
    builder.PrependStructSlot(101, flatbuffers.number_types.UOffsetTFlags.py_type(winddirection80m), 0)

def AddWinddirection80m(builder: flatbuffers.Builder, winddirection80m: Any):
    WeatherCurrentAddWinddirection80m(builder, winddirection80m)

def WeatherCurrentAddWindgusts10m(builder: flatbuffers.Builder, windgusts10m: Any):
    builder.PrependStructSlot(102, flatbuffers.number_types.UOffsetTFlags.py_type(windgusts10m), 0)

def AddWindgusts10m(builder: flatbuffers.Builder, windgusts10m: Any):
    WeatherCurrentAddWindgusts10m(builder, windgusts10m)

def WeatherCurrentAddWindspeed100m(builder: flatbuffers.Builder, windspeed100m: Any):
    builder.PrependStructSlot(103, flatbuffers.number_types.UOffsetTFlags.py_type(windspeed100m), 0)

def AddWindspeed100m(builder: flatbuffers.Builder, windspeed100m: Any):
    WeatherCurrentAddWindspeed100m(builder, windspeed100m)

def WeatherCurrentAddWindspeed10m(builder: flatbuffers.Builder, windspeed10m: Any):
    builder.PrependStructSlot(104, flatbuffers.number_types.UOffsetTFlags.py_type(windspeed10m), 0)

def AddWindspeed10m(builder: flatbuffers.Builder, windspeed10m: Any):
    WeatherCurrentAddWindspeed10m(builder, windspeed10m)

def WeatherCurrentAddWindspeed120m(builder: flatbuffers.Builder, windspeed120m: Any):
    builder.PrependStructSlot(105, flatbuffers.number_types.UOffsetTFlags.py_type(windspeed120m), 0)

def AddWindspeed120m(builder: flatbuffers.Builder, windspeed120m: Any):
    WeatherCurrentAddWindspeed120m(builder, windspeed120m)

def WeatherCurrentAddWindspeed150m(builder: flatbuffers.Builder, windspeed150m: Any):
    builder.PrependStructSlot(106, flatbuffers.number_types.UOffsetTFlags.py_type(windspeed150m), 0)

def AddWindspeed150m(builder: flatbuffers.Builder, windspeed150m: Any):
    WeatherCurrentAddWindspeed150m(builder, windspeed150m)

def WeatherCurrentAddWindspeed180m(builder: flatbuffers.Builder, windspeed180m: Any):
    builder.PrependStructSlot(107, flatbuffers.number_types.UOffsetTFlags.py_type(windspeed180m), 0)

def AddWindspeed180m(builder: flatbuffers.Builder, windspeed180m: Any):
    WeatherCurrentAddWindspeed180m(builder, windspeed180m)

def WeatherCurrentAddWindspeed200m(builder: flatbuffers.Builder, windspeed200m: Any):
    builder.PrependStructSlot(108, flatbuffers.number_types.UOffsetTFlags.py_type(windspeed200m), 0)

def AddWindspeed200m(builder: flatbuffers.Builder, windspeed200m: Any):
    WeatherCurrentAddWindspeed200m(builder, windspeed200m)

def WeatherCurrentAddWindspeed20m(builder: flatbuffers.Builder, windspeed20m: Any):
    builder.PrependStructSlot(109, flatbuffers.number_types.UOffsetTFlags.py_type(windspeed20m), 0)

def AddWindspeed20m(builder: flatbuffers.Builder, windspeed20m: Any):
    WeatherCurrentAddWindspeed20m(builder, windspeed20m)

def WeatherCurrentAddWindspeed40m(builder: flatbuffers.Builder, windspeed40m: Any):
    builder.PrependStructSlot(110, flatbuffers.number_types.UOffsetTFlags.py_type(windspeed40m), 0)

def AddWindspeed40m(builder: flatbuffers.Builder, windspeed40m: Any):
    WeatherCurrentAddWindspeed40m(builder, windspeed40m)

def WeatherCurrentAddWindspeed50m(builder: flatbuffers.Builder, windspeed50m: Any):
    builder.PrependStructSlot(111, flatbuffers.number_types.UOffsetTFlags.py_type(windspeed50m), 0)

def AddWindspeed50m(builder: flatbuffers.Builder, windspeed50m: Any):
    WeatherCurrentAddWindspeed50m(builder, windspeed50m)

def WeatherCurrentAddWindspeed80m(builder: flatbuffers.Builder, windspeed80m: Any):
    builder.PrependStructSlot(112, flatbuffers.number_types.UOffsetTFlags.py_type(windspeed80m), 0)

def AddWindspeed80m(builder: flatbuffers.Builder, windspeed80m: Any):
    WeatherCurrentAddWindspeed80m(builder, windspeed80m)

def WeatherCurrentAddWetBulbTemperature2m(builder: flatbuffers.Builder, wetBulbTemperature2m: Any):
    builder.PrependStructSlot(113, flatbuffers.number_types.UOffsetTFlags.py_type(wetBulbTemperature2m), 0)

def AddWetBulbTemperature2m(builder: flatbuffers.Builder, wetBulbTemperature2m: Any):
    WeatherCurrentAddWetBulbTemperature2m(builder, wetBulbTemperature2m)

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

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