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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def EnsembleHourlyStart(builder: flatbuffers.Builder):
    builder.StartObject(58)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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