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

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

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

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

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

    # WeatherHourly
    def ApparentTemperature(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

    # WeatherHourly
    def Cape(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

    # WeatherHourly
    def Cloudcover(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

    # WeatherHourly
    def CloudcoverHigh(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

    # WeatherHourly
    def CloudcoverLow(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

    # WeatherHourly
    def CloudcoverMid(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

    # WeatherHourly
    def Dewpoint2m(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

    # WeatherHourly
    def DiffuseRadiation(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

    # WeatherHourly
    def DiffuseRadiationInstant(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

    # WeatherHourly
    def DirectNormalIrradiance(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

    # WeatherHourly
    def DirectNormalIrradianceInstant(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

    # WeatherHourly
    def DirectRadiation(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

    # WeatherHourly
    def DirectRadiationInstant(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

    # WeatherHourly
    def Et0FaoEvapotranspiration(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

    # WeatherHourly
    def Evapotranspiration(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

    # WeatherHourly
    def FreezinglevelHeight(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

    # WeatherHourly
    def GrowingDegreeDaysBase0Limit50(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

    # WeatherHourly
    def IsDay(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

    # WeatherHourly
    def LatentHeatflux(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

    # WeatherHourly
    def LeafWetnessProbability(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

    # WeatherHourly
    def LiftedIndex(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

    # WeatherHourly
    def LightningPotential(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

    # WeatherHourly
    def Precipitation(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

    # WeatherHourly
    def PrecipitationProbability(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

    # WeatherHourly
    def PressureMsl(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

    # WeatherHourly
    def Rain(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

    # WeatherHourly
    def Relativehumidity2m(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

    # WeatherHourly
    def Runoff(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

    # WeatherHourly
    def SensibleHeatflux(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

    # WeatherHourly
    def ShortwaveRadiation(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

    # WeatherHourly
    def ShortwaveRadiationInstant(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

    # WeatherHourly
    def Showers(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

    # WeatherHourly
    def SnowDepth(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

    # WeatherHourly
    def SnowHeight(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

    # WeatherHourly
    def Snowfall(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

    # WeatherHourly
    def SnowfallHeight(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

    # WeatherHourly
    def SnowfallWaterEquivalent(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

    # WeatherHourly
    def SoilMoisture0To1cm(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

    # WeatherHourly
    def SoilMoisture0To100cm(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

    # WeatherHourly
    def SoilMoisture0To10cm(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

    # WeatherHourly
    def SoilMoisture0To7cm(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

    # WeatherHourly
    def SoilMoisture100To200cm(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

    # WeatherHourly
    def SoilMoisture100To255cm(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

    # WeatherHourly
    def SoilMoisture10To40cm(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

    # WeatherHourly
    def SoilMoisture1To3cm(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

    # WeatherHourly
    def SoilMoisture27To81cm(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

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

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

    # WeatherHourly
    def SoilMoisture40To100cm(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

    # WeatherHourly
    def SoilMoisture7To28cm(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

    # WeatherHourly
    def SoilMoisture9To27cm(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

    # WeatherHourly
    def SoilMoistureIndex0To100cm(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

    # WeatherHourly
    def SoilMoistureIndex0To7cm(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

    # WeatherHourly
    def SoilMoistureIndex100To255cm(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

    # WeatherHourly
    def SoilMoistureIndex28To100cm(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

    # WeatherHourly
    def SoilMoistureIndex7To28cm(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

    # WeatherHourly
    def SoilTemperature0To100cm(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

    # WeatherHourly
    def SoilTemperature0To10cm(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

    # WeatherHourly
    def SoilTemperature0To7cm(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

    # WeatherHourly
    def SoilTemperature0cm(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

    # WeatherHourly
    def SoilTemperature100To200cm(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

    # WeatherHourly
    def SoilTemperature100To255cm(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

    # WeatherHourly
    def SoilTemperature10To40cm(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

    # WeatherHourly
    def SoilTemperature18cm(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

    # WeatherHourly
    def SoilTemperature28To100cm(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

    # WeatherHourly
    def SoilTemperature40To100cm(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

    # WeatherHourly
    def SoilTemperature54cm(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

    # WeatherHourly
    def SoilTemperature6cm(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

    # WeatherHourly
    def SoilTemperature7To28cm(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

    # WeatherHourly
    def SurfacePressure(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

    # WeatherHourly
    def SurfaceTemperature(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

    # WeatherHourly
    def Temperature100m(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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def WeatherHourlyStart(builder: flatbuffers.Builder):
    builder.StartObject(121)

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

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

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

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

def AddApparentTemperature(builder: flatbuffers.Builder, apparentTemperature: int):
    WeatherHourlyAddApparentTemperature(builder, apparentTemperature)

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

def AddCape(builder: flatbuffers.Builder, cape: int):
    WeatherHourlyAddCape(builder, cape)

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

def AddCloudcover(builder: flatbuffers.Builder, cloudcover: int):
    WeatherHourlyAddCloudcover(builder, cloudcover)

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

def AddCloudcoverHigh(builder: flatbuffers.Builder, cloudcoverHigh: int):
    WeatherHourlyAddCloudcoverHigh(builder, cloudcoverHigh)

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

def AddCloudcoverLow(builder: flatbuffers.Builder, cloudcoverLow: int):
    WeatherHourlyAddCloudcoverLow(builder, cloudcoverLow)

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

def AddCloudcoverMid(builder: flatbuffers.Builder, cloudcoverMid: int):
    WeatherHourlyAddCloudcoverMid(builder, cloudcoverMid)

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

def AddDewpoint2m(builder: flatbuffers.Builder, dewpoint2m: int):
    WeatherHourlyAddDewpoint2m(builder, dewpoint2m)

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

def AddDiffuseRadiation(builder: flatbuffers.Builder, diffuseRadiation: int):
    WeatherHourlyAddDiffuseRadiation(builder, diffuseRadiation)

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

def AddDiffuseRadiationInstant(builder: flatbuffers.Builder, diffuseRadiationInstant: int):
    WeatherHourlyAddDiffuseRadiationInstant(builder, diffuseRadiationInstant)

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

def AddDirectNormalIrradiance(builder: flatbuffers.Builder, directNormalIrradiance: int):
    WeatherHourlyAddDirectNormalIrradiance(builder, directNormalIrradiance)

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

def AddDirectNormalIrradianceInstant(builder: flatbuffers.Builder, directNormalIrradianceInstant: int):
    WeatherHourlyAddDirectNormalIrradianceInstant(builder, directNormalIrradianceInstant)

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

def AddDirectRadiation(builder: flatbuffers.Builder, directRadiation: int):
    WeatherHourlyAddDirectRadiation(builder, directRadiation)

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

def AddDirectRadiationInstant(builder: flatbuffers.Builder, directRadiationInstant: int):
    WeatherHourlyAddDirectRadiationInstant(builder, directRadiationInstant)

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

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

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

def AddEvapotranspiration(builder: flatbuffers.Builder, evapotranspiration: int):
    WeatherHourlyAddEvapotranspiration(builder, evapotranspiration)

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

def AddFreezinglevelHeight(builder: flatbuffers.Builder, freezinglevelHeight: int):
    WeatherHourlyAddFreezinglevelHeight(builder, freezinglevelHeight)

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

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

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

def AddIsDay(builder: flatbuffers.Builder, isDay: int):
    WeatherHourlyAddIsDay(builder, isDay)

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

def AddLatentHeatflux(builder: flatbuffers.Builder, latentHeatflux: int):
    WeatherHourlyAddLatentHeatflux(builder, latentHeatflux)

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

def AddLeafWetnessProbability(builder: flatbuffers.Builder, leafWetnessProbability: int):
    WeatherHourlyAddLeafWetnessProbability(builder, leafWetnessProbability)

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

def AddLiftedIndex(builder: flatbuffers.Builder, liftedIndex: int):
    WeatherHourlyAddLiftedIndex(builder, liftedIndex)

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

def AddLightningPotential(builder: flatbuffers.Builder, lightningPotential: int):
    WeatherHourlyAddLightningPotential(builder, lightningPotential)

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

def AddPrecipitation(builder: flatbuffers.Builder, precipitation: int):
    WeatherHourlyAddPrecipitation(builder, precipitation)

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

def AddPrecipitationProbability(builder: flatbuffers.Builder, precipitationProbability: int):
    WeatherHourlyAddPrecipitationProbability(builder, precipitationProbability)

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

def AddPressureMsl(builder: flatbuffers.Builder, pressureMsl: int):
    WeatherHourlyAddPressureMsl(builder, pressureMsl)

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

def AddRain(builder: flatbuffers.Builder, rain: int):
    WeatherHourlyAddRain(builder, rain)

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

def AddRelativehumidity2m(builder: flatbuffers.Builder, relativehumidity2m: int):
    WeatherHourlyAddRelativehumidity2m(builder, relativehumidity2m)

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

def AddRunoff(builder: flatbuffers.Builder, runoff: int):
    WeatherHourlyAddRunoff(builder, runoff)

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

def AddSensibleHeatflux(builder: flatbuffers.Builder, sensibleHeatflux: int):
    WeatherHourlyAddSensibleHeatflux(builder, sensibleHeatflux)

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

def AddShortwaveRadiation(builder: flatbuffers.Builder, shortwaveRadiation: int):
    WeatherHourlyAddShortwaveRadiation(builder, shortwaveRadiation)

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

def AddShortwaveRadiationInstant(builder: flatbuffers.Builder, shortwaveRadiationInstant: int):
    WeatherHourlyAddShortwaveRadiationInstant(builder, shortwaveRadiationInstant)

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

def AddShowers(builder: flatbuffers.Builder, showers: int):
    WeatherHourlyAddShowers(builder, showers)

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

def AddSnowDepth(builder: flatbuffers.Builder, snowDepth: int):
    WeatherHourlyAddSnowDepth(builder, snowDepth)

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

def AddSnowHeight(builder: flatbuffers.Builder, snowHeight: int):
    WeatherHourlyAddSnowHeight(builder, snowHeight)

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

def AddSnowfall(builder: flatbuffers.Builder, snowfall: int):
    WeatherHourlyAddSnowfall(builder, snowfall)

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

def AddSnowfallHeight(builder: flatbuffers.Builder, snowfallHeight: int):
    WeatherHourlyAddSnowfallHeight(builder, snowfallHeight)

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

def AddSnowfallWaterEquivalent(builder: flatbuffers.Builder, snowfallWaterEquivalent: int):
    WeatherHourlyAddSnowfallWaterEquivalent(builder, snowfallWaterEquivalent)

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

def AddSoilMoisture0To1cm(builder: flatbuffers.Builder, soilMoisture0To1cm: int):
    WeatherHourlyAddSoilMoisture0To1cm(builder, soilMoisture0To1cm)

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

def AddSoilMoisture0To100cm(builder: flatbuffers.Builder, soilMoisture0To100cm: int):
    WeatherHourlyAddSoilMoisture0To100cm(builder, soilMoisture0To100cm)

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

def AddSoilMoisture0To10cm(builder: flatbuffers.Builder, soilMoisture0To10cm: int):
    WeatherHourlyAddSoilMoisture0To10cm(builder, soilMoisture0To10cm)

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

def AddSoilMoisture0To7cm(builder: flatbuffers.Builder, soilMoisture0To7cm: int):
    WeatherHourlyAddSoilMoisture0To7cm(builder, soilMoisture0To7cm)

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

def AddSoilMoisture100To200cm(builder: flatbuffers.Builder, soilMoisture100To200cm: int):
    WeatherHourlyAddSoilMoisture100To200cm(builder, soilMoisture100To200cm)

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

def AddSoilMoisture100To255cm(builder: flatbuffers.Builder, soilMoisture100To255cm: int):
    WeatherHourlyAddSoilMoisture100To255cm(builder, soilMoisture100To255cm)

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

def AddSoilMoisture10To40cm(builder: flatbuffers.Builder, soilMoisture10To40cm: int):
    WeatherHourlyAddSoilMoisture10To40cm(builder, soilMoisture10To40cm)

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

def AddSoilMoisture1To3cm(builder: flatbuffers.Builder, soilMoisture1To3cm: int):
    WeatherHourlyAddSoilMoisture1To3cm(builder, soilMoisture1To3cm)

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

def AddSoilMoisture27To81cm(builder: flatbuffers.Builder, soilMoisture27To81cm: int):
    WeatherHourlyAddSoilMoisture27To81cm(builder, soilMoisture27To81cm)

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

def AddSoilMoisture28To100cm(builder: flatbuffers.Builder, soilMoisture28To100cm: int):
    WeatherHourlyAddSoilMoisture28To100cm(builder, soilMoisture28To100cm)

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

def AddSoilMoisture3To9cm(builder: flatbuffers.Builder, soilMoisture3To9cm: int):
    WeatherHourlyAddSoilMoisture3To9cm(builder, soilMoisture3To9cm)

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

def AddSoilMoisture40To100cm(builder: flatbuffers.Builder, soilMoisture40To100cm: int):
    WeatherHourlyAddSoilMoisture40To100cm(builder, soilMoisture40To100cm)

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

def AddSoilMoisture7To28cm(builder: flatbuffers.Builder, soilMoisture7To28cm: int):
    WeatherHourlyAddSoilMoisture7To28cm(builder, soilMoisture7To28cm)

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

def AddSoilMoisture9To27cm(builder: flatbuffers.Builder, soilMoisture9To27cm: int):
    WeatherHourlyAddSoilMoisture9To27cm(builder, soilMoisture9To27cm)

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

def AddSoilMoistureIndex0To100cm(builder: flatbuffers.Builder, soilMoistureIndex0To100cm: int):
    WeatherHourlyAddSoilMoistureIndex0To100cm(builder, soilMoistureIndex0To100cm)

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

def AddSoilMoistureIndex0To7cm(builder: flatbuffers.Builder, soilMoistureIndex0To7cm: int):
    WeatherHourlyAddSoilMoistureIndex0To7cm(builder, soilMoistureIndex0To7cm)

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

def AddSoilMoistureIndex100To255cm(builder: flatbuffers.Builder, soilMoistureIndex100To255cm: int):
    WeatherHourlyAddSoilMoistureIndex100To255cm(builder, soilMoistureIndex100To255cm)

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

def AddSoilMoistureIndex28To100cm(builder: flatbuffers.Builder, soilMoistureIndex28To100cm: int):
    WeatherHourlyAddSoilMoistureIndex28To100cm(builder, soilMoistureIndex28To100cm)

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

def AddSoilMoistureIndex7To28cm(builder: flatbuffers.Builder, soilMoistureIndex7To28cm: int):
    WeatherHourlyAddSoilMoistureIndex7To28cm(builder, soilMoistureIndex7To28cm)

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

def AddSoilTemperature0To100cm(builder: flatbuffers.Builder, soilTemperature0To100cm: int):
    WeatherHourlyAddSoilTemperature0To100cm(builder, soilTemperature0To100cm)

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

def AddSoilTemperature0To10cm(builder: flatbuffers.Builder, soilTemperature0To10cm: int):
    WeatherHourlyAddSoilTemperature0To10cm(builder, soilTemperature0To10cm)

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

def AddSoilTemperature0To7cm(builder: flatbuffers.Builder, soilTemperature0To7cm: int):
    WeatherHourlyAddSoilTemperature0To7cm(builder, soilTemperature0To7cm)

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

def AddSoilTemperature0cm(builder: flatbuffers.Builder, soilTemperature0cm: int):
    WeatherHourlyAddSoilTemperature0cm(builder, soilTemperature0cm)

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

def AddSoilTemperature100To200cm(builder: flatbuffers.Builder, soilTemperature100To200cm: int):
    WeatherHourlyAddSoilTemperature100To200cm(builder, soilTemperature100To200cm)

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

def AddSoilTemperature100To255cm(builder: flatbuffers.Builder, soilTemperature100To255cm: int):
    WeatherHourlyAddSoilTemperature100To255cm(builder, soilTemperature100To255cm)

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

def AddSoilTemperature10To40cm(builder: flatbuffers.Builder, soilTemperature10To40cm: int):
    WeatherHourlyAddSoilTemperature10To40cm(builder, soilTemperature10To40cm)

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

def AddSoilTemperature18cm(builder: flatbuffers.Builder, soilTemperature18cm: int):
    WeatherHourlyAddSoilTemperature18cm(builder, soilTemperature18cm)

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

def AddSoilTemperature28To100cm(builder: flatbuffers.Builder, soilTemperature28To100cm: int):
    WeatherHourlyAddSoilTemperature28To100cm(builder, soilTemperature28To100cm)

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

def AddSoilTemperature40To100cm(builder: flatbuffers.Builder, soilTemperature40To100cm: int):
    WeatherHourlyAddSoilTemperature40To100cm(builder, soilTemperature40To100cm)

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

def AddSoilTemperature54cm(builder: flatbuffers.Builder, soilTemperature54cm: int):
    WeatherHourlyAddSoilTemperature54cm(builder, soilTemperature54cm)

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

def AddSoilTemperature6cm(builder: flatbuffers.Builder, soilTemperature6cm: int):
    WeatherHourlyAddSoilTemperature6cm(builder, soilTemperature6cm)

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

def AddSoilTemperature7To28cm(builder: flatbuffers.Builder, soilTemperature7To28cm: int):
    WeatherHourlyAddSoilTemperature7To28cm(builder, soilTemperature7To28cm)

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

def AddSurfacePressure(builder: flatbuffers.Builder, surfacePressure: int):
    WeatherHourlyAddSurfacePressure(builder, surfacePressure)

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

def AddSurfaceTemperature(builder: flatbuffers.Builder, surfaceTemperature: int):
    WeatherHourlyAddSurfaceTemperature(builder, surfaceTemperature)

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

def AddTemperature100m(builder: flatbuffers.Builder, temperature100m: int):
    WeatherHourlyAddTemperature100m(builder, temperature100m)

def WeatherHourlyAddTemperature120m(builder: flatbuffers.Builder, temperature120m: int):
    builder.PrependUOffsetTRelativeSlot(73, flatbuffers.number_types.UOffsetTFlags.py_type(temperature120m), 0)

def AddTemperature120m(builder: flatbuffers.Builder, temperature120m: int):
    WeatherHourlyAddTemperature120m(builder, temperature120m)

def WeatherHourlyAddTemperature150m(builder: flatbuffers.Builder, temperature150m: int):
    builder.PrependUOffsetTRelativeSlot(74, flatbuffers.number_types.UOffsetTFlags.py_type(temperature150m), 0)

def AddTemperature150m(builder: flatbuffers.Builder, temperature150m: int):
    WeatherHourlyAddTemperature150m(builder, temperature150m)

def WeatherHourlyAddTemperature180m(builder: flatbuffers.Builder, temperature180m: int):
    builder.PrependUOffsetTRelativeSlot(75, flatbuffers.number_types.UOffsetTFlags.py_type(temperature180m), 0)

def AddTemperature180m(builder: flatbuffers.Builder, temperature180m: int):
    WeatherHourlyAddTemperature180m(builder, temperature180m)

def WeatherHourlyAddTemperature2m(builder: flatbuffers.Builder, temperature2m: int):
    builder.PrependUOffsetTRelativeSlot(76, flatbuffers.number_types.UOffsetTFlags.py_type(temperature2m), 0)

def AddTemperature2m(builder: flatbuffers.Builder, temperature2m: int):
    WeatherHourlyAddTemperature2m(builder, temperature2m)

def WeatherHourlyAddTemperature20m(builder: flatbuffers.Builder, temperature20m: int):
    builder.PrependUOffsetTRelativeSlot(77, flatbuffers.number_types.UOffsetTFlags.py_type(temperature20m), 0)

def AddTemperature20m(builder: flatbuffers.Builder, temperature20m: int):
    WeatherHourlyAddTemperature20m(builder, temperature20m)

def WeatherHourlyAddTemperature200m(builder: flatbuffers.Builder, temperature200m: int):
    builder.PrependUOffsetTRelativeSlot(78, flatbuffers.number_types.UOffsetTFlags.py_type(temperature200m), 0)

def AddTemperature200m(builder: flatbuffers.Builder, temperature200m: int):
    WeatherHourlyAddTemperature200m(builder, temperature200m)

def WeatherHourlyAddTemperature50m(builder: flatbuffers.Builder, temperature50m: int):
    builder.PrependUOffsetTRelativeSlot(79, flatbuffers.number_types.UOffsetTFlags.py_type(temperature50m), 0)

def AddTemperature50m(builder: flatbuffers.Builder, temperature50m: int):
    WeatherHourlyAddTemperature50m(builder, temperature50m)

def WeatherHourlyAddTemperature40m(builder: flatbuffers.Builder, temperature40m: int):
    builder.PrependUOffsetTRelativeSlot(80, flatbuffers.number_types.UOffsetTFlags.py_type(temperature40m), 0)

def AddTemperature40m(builder: flatbuffers.Builder, temperature40m: int):
    WeatherHourlyAddTemperature40m(builder, temperature40m)

def WeatherHourlyAddTemperature80m(builder: flatbuffers.Builder, temperature80m: int):
    builder.PrependUOffsetTRelativeSlot(81, flatbuffers.number_types.UOffsetTFlags.py_type(temperature80m), 0)

def AddTemperature80m(builder: flatbuffers.Builder, temperature80m: int):
    WeatherHourlyAddTemperature80m(builder, temperature80m)

def WeatherHourlyAddTerrestrialRadiation(builder: flatbuffers.Builder, terrestrialRadiation: int):
    builder.PrependUOffsetTRelativeSlot(82, flatbuffers.number_types.UOffsetTFlags.py_type(terrestrialRadiation), 0)

def AddTerrestrialRadiation(builder: flatbuffers.Builder, terrestrialRadiation: int):
    WeatherHourlyAddTerrestrialRadiation(builder, terrestrialRadiation)

def WeatherHourlyAddTerrestrialRadiationInstant(builder: flatbuffers.Builder, terrestrialRadiationInstant: int):
    builder.PrependUOffsetTRelativeSlot(83, flatbuffers.number_types.UOffsetTFlags.py_type(terrestrialRadiationInstant), 0)

def AddTerrestrialRadiationInstant(builder: flatbuffers.Builder, terrestrialRadiationInstant: int):
    WeatherHourlyAddTerrestrialRadiationInstant(builder, terrestrialRadiationInstant)

def WeatherHourlyAddTotalColumnIntegratedWaterVapour(builder: flatbuffers.Builder, totalColumnIntegratedWaterVapour: int):
    builder.PrependUOffsetTRelativeSlot(84, flatbuffers.number_types.UOffsetTFlags.py_type(totalColumnIntegratedWaterVapour), 0)

def AddTotalColumnIntegratedWaterVapour(builder: flatbuffers.Builder, totalColumnIntegratedWaterVapour: int):
    WeatherHourlyAddTotalColumnIntegratedWaterVapour(builder, totalColumnIntegratedWaterVapour)

def WeatherHourlyAddUpdraft(builder: flatbuffers.Builder, updraft: int):
    builder.PrependUOffsetTRelativeSlot(85, flatbuffers.number_types.UOffsetTFlags.py_type(updraft), 0)

def AddUpdraft(builder: flatbuffers.Builder, updraft: int):
    WeatherHourlyAddUpdraft(builder, updraft)

def WeatherHourlyAddUvIndex(builder: flatbuffers.Builder, uvIndex: int):
    builder.PrependUOffsetTRelativeSlot(86, flatbuffers.number_types.UOffsetTFlags.py_type(uvIndex), 0)

def AddUvIndex(builder: flatbuffers.Builder, uvIndex: int):
    WeatherHourlyAddUvIndex(builder, uvIndex)

def WeatherHourlyAddUvIndexClearSky(builder: flatbuffers.Builder, uvIndexClearSky: int):
    builder.PrependUOffsetTRelativeSlot(87, flatbuffers.number_types.UOffsetTFlags.py_type(uvIndexClearSky), 0)

def AddUvIndexClearSky(builder: flatbuffers.Builder, uvIndexClearSky: int):
    WeatherHourlyAddUvIndexClearSky(builder, uvIndexClearSky)

def WeatherHourlyAddVaporPressureDeficit(builder: flatbuffers.Builder, vaporPressureDeficit: int):
    builder.PrependUOffsetTRelativeSlot(88, flatbuffers.number_types.UOffsetTFlags.py_type(vaporPressureDeficit), 0)

def AddVaporPressureDeficit(builder: flatbuffers.Builder, vaporPressureDeficit: int):
    WeatherHourlyAddVaporPressureDeficit(builder, vaporPressureDeficit)

def WeatherHourlyAddVisibility(builder: flatbuffers.Builder, visibility: int):
    builder.PrependUOffsetTRelativeSlot(89, flatbuffers.number_types.UOffsetTFlags.py_type(visibility), 0)

def AddVisibility(builder: flatbuffers.Builder, visibility: int):
    WeatherHourlyAddVisibility(builder, visibility)

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

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

def WeatherHourlyAddWinddirection100m(builder: flatbuffers.Builder, winddirection100m: int):
    builder.PrependUOffsetTRelativeSlot(91, flatbuffers.number_types.UOffsetTFlags.py_type(winddirection100m), 0)

def AddWinddirection100m(builder: flatbuffers.Builder, winddirection100m: int):
    WeatherHourlyAddWinddirection100m(builder, winddirection100m)

def WeatherHourlyAddWinddirection10m(builder: flatbuffers.Builder, winddirection10m: int):
    builder.PrependUOffsetTRelativeSlot(92, flatbuffers.number_types.UOffsetTFlags.py_type(winddirection10m), 0)

def AddWinddirection10m(builder: flatbuffers.Builder, winddirection10m: int):
    WeatherHourlyAddWinddirection10m(builder, winddirection10m)

def WeatherHourlyAddWinddirection120m(builder: flatbuffers.Builder, winddirection120m: int):
    builder.PrependUOffsetTRelativeSlot(93, flatbuffers.number_types.UOffsetTFlags.py_type(winddirection120m), 0)

def AddWinddirection120m(builder: flatbuffers.Builder, winddirection120m: int):
    WeatherHourlyAddWinddirection120m(builder, winddirection120m)

def WeatherHourlyAddWinddirection150m(builder: flatbuffers.Builder, winddirection150m: int):
    builder.PrependUOffsetTRelativeSlot(94, flatbuffers.number_types.UOffsetTFlags.py_type(winddirection150m), 0)

def AddWinddirection150m(builder: flatbuffers.Builder, winddirection150m: int):
    WeatherHourlyAddWinddirection150m(builder, winddirection150m)

def WeatherHourlyAddWinddirection180m(builder: flatbuffers.Builder, winddirection180m: int):
    builder.PrependUOffsetTRelativeSlot(95, flatbuffers.number_types.UOffsetTFlags.py_type(winddirection180m), 0)

def AddWinddirection180m(builder: flatbuffers.Builder, winddirection180m: int):
    WeatherHourlyAddWinddirection180m(builder, winddirection180m)

def WeatherHourlyAddWinddirection200m(builder: flatbuffers.Builder, winddirection200m: int):
    builder.PrependUOffsetTRelativeSlot(96, flatbuffers.number_types.UOffsetTFlags.py_type(winddirection200m), 0)

def AddWinddirection200m(builder: flatbuffers.Builder, winddirection200m: int):
    WeatherHourlyAddWinddirection200m(builder, winddirection200m)

def WeatherHourlyAddWinddirection20m(builder: flatbuffers.Builder, winddirection20m: int):
    builder.PrependUOffsetTRelativeSlot(97, flatbuffers.number_types.UOffsetTFlags.py_type(winddirection20m), 0)

def AddWinddirection20m(builder: flatbuffers.Builder, winddirection20m: int):
    WeatherHourlyAddWinddirection20m(builder, winddirection20m)

def WeatherHourlyAddWinddirection40m(builder: flatbuffers.Builder, winddirection40m: int):
    builder.PrependUOffsetTRelativeSlot(98, flatbuffers.number_types.UOffsetTFlags.py_type(winddirection40m), 0)

def AddWinddirection40m(builder: flatbuffers.Builder, winddirection40m: int):
    WeatherHourlyAddWinddirection40m(builder, winddirection40m)

def WeatherHourlyAddWinddirection50m(builder: flatbuffers.Builder, winddirection50m: int):
    builder.PrependUOffsetTRelativeSlot(99, flatbuffers.number_types.UOffsetTFlags.py_type(winddirection50m), 0)

def AddWinddirection50m(builder: flatbuffers.Builder, winddirection50m: int):
    WeatherHourlyAddWinddirection50m(builder, winddirection50m)

def WeatherHourlyAddWinddirection80m(builder: flatbuffers.Builder, winddirection80m: int):
    builder.PrependUOffsetTRelativeSlot(100, flatbuffers.number_types.UOffsetTFlags.py_type(winddirection80m), 0)

def AddWinddirection80m(builder: flatbuffers.Builder, winddirection80m: int):
    WeatherHourlyAddWinddirection80m(builder, winddirection80m)

def WeatherHourlyAddWindgusts10m(builder: flatbuffers.Builder, windgusts10m: int):
    builder.PrependUOffsetTRelativeSlot(101, flatbuffers.number_types.UOffsetTFlags.py_type(windgusts10m), 0)

def AddWindgusts10m(builder: flatbuffers.Builder, windgusts10m: int):
    WeatherHourlyAddWindgusts10m(builder, windgusts10m)

def WeatherHourlyAddWindspeed100m(builder: flatbuffers.Builder, windspeed100m: int):
    builder.PrependUOffsetTRelativeSlot(102, flatbuffers.number_types.UOffsetTFlags.py_type(windspeed100m), 0)

def AddWindspeed100m(builder: flatbuffers.Builder, windspeed100m: int):
    WeatherHourlyAddWindspeed100m(builder, windspeed100m)

def WeatherHourlyAddWindspeed10m(builder: flatbuffers.Builder, windspeed10m: int):
    builder.PrependUOffsetTRelativeSlot(103, flatbuffers.number_types.UOffsetTFlags.py_type(windspeed10m), 0)

def AddWindspeed10m(builder: flatbuffers.Builder, windspeed10m: int):
    WeatherHourlyAddWindspeed10m(builder, windspeed10m)

def WeatherHourlyAddWindspeed120m(builder: flatbuffers.Builder, windspeed120m: int):
    builder.PrependUOffsetTRelativeSlot(104, flatbuffers.number_types.UOffsetTFlags.py_type(windspeed120m), 0)

def AddWindspeed120m(builder: flatbuffers.Builder, windspeed120m: int):
    WeatherHourlyAddWindspeed120m(builder, windspeed120m)

def WeatherHourlyAddWindspeed150m(builder: flatbuffers.Builder, windspeed150m: int):
    builder.PrependUOffsetTRelativeSlot(105, flatbuffers.number_types.UOffsetTFlags.py_type(windspeed150m), 0)

def AddWindspeed150m(builder: flatbuffers.Builder, windspeed150m: int):
    WeatherHourlyAddWindspeed150m(builder, windspeed150m)

def WeatherHourlyAddWindspeed180m(builder: flatbuffers.Builder, windspeed180m: int):
    builder.PrependUOffsetTRelativeSlot(106, flatbuffers.number_types.UOffsetTFlags.py_type(windspeed180m), 0)

def AddWindspeed180m(builder: flatbuffers.Builder, windspeed180m: int):
    WeatherHourlyAddWindspeed180m(builder, windspeed180m)

def WeatherHourlyAddWindspeed200m(builder: flatbuffers.Builder, windspeed200m: int):
    builder.PrependUOffsetTRelativeSlot(107, flatbuffers.number_types.UOffsetTFlags.py_type(windspeed200m), 0)

def AddWindspeed200m(builder: flatbuffers.Builder, windspeed200m: int):
    WeatherHourlyAddWindspeed200m(builder, windspeed200m)

def WeatherHourlyAddWindspeed20m(builder: flatbuffers.Builder, windspeed20m: int):
    builder.PrependUOffsetTRelativeSlot(108, flatbuffers.number_types.UOffsetTFlags.py_type(windspeed20m), 0)

def AddWindspeed20m(builder: flatbuffers.Builder, windspeed20m: int):
    WeatherHourlyAddWindspeed20m(builder, windspeed20m)

def WeatherHourlyAddWindspeed40m(builder: flatbuffers.Builder, windspeed40m: int):
    builder.PrependUOffsetTRelativeSlot(109, flatbuffers.number_types.UOffsetTFlags.py_type(windspeed40m), 0)

def AddWindspeed40m(builder: flatbuffers.Builder, windspeed40m: int):
    WeatherHourlyAddWindspeed40m(builder, windspeed40m)

def WeatherHourlyAddWindspeed50m(builder: flatbuffers.Builder, windspeed50m: int):
    builder.PrependUOffsetTRelativeSlot(110, flatbuffers.number_types.UOffsetTFlags.py_type(windspeed50m), 0)

def AddWindspeed50m(builder: flatbuffers.Builder, windspeed50m: int):
    WeatherHourlyAddWindspeed50m(builder, windspeed50m)

def WeatherHourlyAddWindspeed80m(builder: flatbuffers.Builder, windspeed80m: int):
    builder.PrependUOffsetTRelativeSlot(111, flatbuffers.number_types.UOffsetTFlags.py_type(windspeed80m), 0)

def AddWindspeed80m(builder: flatbuffers.Builder, windspeed80m: int):
    WeatherHourlyAddWindspeed80m(builder, windspeed80m)

def WeatherHourlyAddPressureLevelTemperature(builder: flatbuffers.Builder, pressureLevelTemperature: int):
    builder.PrependUOffsetTRelativeSlot(112, flatbuffers.number_types.UOffsetTFlags.py_type(pressureLevelTemperature), 0)

def AddPressureLevelTemperature(builder: flatbuffers.Builder, pressureLevelTemperature: int):
    WeatherHourlyAddPressureLevelTemperature(builder, pressureLevelTemperature)

def WeatherHourlyAddPressureLevelDewpoint(builder: flatbuffers.Builder, pressureLevelDewpoint: int):
    builder.PrependUOffsetTRelativeSlot(113, flatbuffers.number_types.UOffsetTFlags.py_type(pressureLevelDewpoint), 0)

def AddPressureLevelDewpoint(builder: flatbuffers.Builder, pressureLevelDewpoint: int):
    WeatherHourlyAddPressureLevelDewpoint(builder, pressureLevelDewpoint)

def WeatherHourlyAddPressureLevelRelativehumidity(builder: flatbuffers.Builder, pressureLevelRelativehumidity: int):
    builder.PrependUOffsetTRelativeSlot(114, flatbuffers.number_types.UOffsetTFlags.py_type(pressureLevelRelativehumidity), 0)

def AddPressureLevelRelativehumidity(builder: flatbuffers.Builder, pressureLevelRelativehumidity: int):
    WeatherHourlyAddPressureLevelRelativehumidity(builder, pressureLevelRelativehumidity)

def WeatherHourlyAddPressureLevelCloudcover(builder: flatbuffers.Builder, pressureLevelCloudcover: int):
    builder.PrependUOffsetTRelativeSlot(115, flatbuffers.number_types.UOffsetTFlags.py_type(pressureLevelCloudcover), 0)

def AddPressureLevelCloudcover(builder: flatbuffers.Builder, pressureLevelCloudcover: int):
    WeatherHourlyAddPressureLevelCloudcover(builder, pressureLevelCloudcover)

def WeatherHourlyAddPressureLevelWindspeed(builder: flatbuffers.Builder, pressureLevelWindspeed: int):
    builder.PrependUOffsetTRelativeSlot(116, flatbuffers.number_types.UOffsetTFlags.py_type(pressureLevelWindspeed), 0)

def AddPressureLevelWindspeed(builder: flatbuffers.Builder, pressureLevelWindspeed: int):
    WeatherHourlyAddPressureLevelWindspeed(builder, pressureLevelWindspeed)

def WeatherHourlyAddPressureLevelWinddirection(builder: flatbuffers.Builder, pressureLevelWinddirection: int):
    builder.PrependUOffsetTRelativeSlot(117, flatbuffers.number_types.UOffsetTFlags.py_type(pressureLevelWinddirection), 0)

def AddPressureLevelWinddirection(builder: flatbuffers.Builder, pressureLevelWinddirection: int):
    WeatherHourlyAddPressureLevelWinddirection(builder, pressureLevelWinddirection)

def WeatherHourlyAddPressureLevelVerticalVelocity(builder: flatbuffers.Builder, pressureLevelVerticalVelocity: int):
    builder.PrependUOffsetTRelativeSlot(118, flatbuffers.number_types.UOffsetTFlags.py_type(pressureLevelVerticalVelocity), 0)

def AddPressureLevelVerticalVelocity(builder: flatbuffers.Builder, pressureLevelVerticalVelocity: int):
    WeatherHourlyAddPressureLevelVerticalVelocity(builder, pressureLevelVerticalVelocity)

def WeatherHourlyAddPressureLevelGeopotentialHeight(builder: flatbuffers.Builder, pressureLevelGeopotentialHeight: int):
    builder.PrependUOffsetTRelativeSlot(119, flatbuffers.number_types.UOffsetTFlags.py_type(pressureLevelGeopotentialHeight), 0)

def AddPressureLevelGeopotentialHeight(builder: flatbuffers.Builder, pressureLevelGeopotentialHeight: int):
    WeatherHourlyAddPressureLevelGeopotentialHeight(builder, pressureLevelGeopotentialHeight)

def WeatherHourlyAddWetBulbTemperature2m(builder: flatbuffers.Builder, wetBulbTemperature2m: int):
    builder.PrependUOffsetTRelativeSlot(120, flatbuffers.number_types.UOffsetTFlags.py_type(wetBulbTemperature2m), 0)

def AddWetBulbTemperature2m(builder: flatbuffers.Builder, wetBulbTemperature2m: int):
    WeatherHourlyAddWetBulbTemperature2m(builder, wetBulbTemperature2m)

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

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