# automatically generated by the FlatBuffers compiler, do not modify

# namespace: 

import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()

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

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

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

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

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

    # GenerationConfiguration
    def StartHeight(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint16Flags, o + self._tab.Pos)
        return 0

    # GenerationConfiguration
    def Seed(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
        return 0

    # GenerationConfiguration
    def Steps(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
        return 0

    # GenerationConfiguration
    def GuidanceScale(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
        return 0.0

    # GenerationConfiguration
    def Strength(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
        return 0.0

    # GenerationConfiguration
    def Model(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
        if o != 0:
            return self._tab.String(o + self._tab.Pos)
        return None

    # GenerationConfiguration
    def Sampler(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
        return 0

    # GenerationConfiguration
    def BatchCount(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
        return 1

    # GenerationConfiguration
    def BatchSize(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
        return 1

    # GenerationConfiguration
    def HiresFix(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
        if o != 0:
            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
        return False

    # GenerationConfiguration
    def HiresFixStartWidth(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint16Flags, o + self._tab.Pos)
        return 0

    # GenerationConfiguration
    def HiresFixStartHeight(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint16Flags, o + self._tab.Pos)
        return 0

    # GenerationConfiguration
    def HiresFixStrength(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
        return 0.7

    # GenerationConfiguration
    def Upscaler(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(34))
        if o != 0:
            return self._tab.String(o + self._tab.Pos)
        return None

    # GenerationConfiguration
    def ImageGuidanceScale(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(36))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
        return 1.5

    # GenerationConfiguration
    def SeedMode(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(38))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
        return 0

    # GenerationConfiguration
    def ClipSkip(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(40))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
        return 1

    # GenerationConfiguration
    def Controls(self, j):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(42))
        if o != 0:
            x = self._tab.Vector(o)
            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
            x = self._tab.Indirect(x)
            from Control import Control
            obj = Control()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # GenerationConfiguration
    def ControlsLength(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(42))
        if o != 0:
            return self._tab.VectorLen(o)
        return 0

    # GenerationConfiguration
    def ControlsIsNone(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(42))
        return o == 0

    # GenerationConfiguration
    def Loras(self, j):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(44))
        if o != 0:
            x = self._tab.Vector(o)
            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
            x = self._tab.Indirect(x)
            from LoRA import LoRA
            obj = LoRA()
            obj.Init(self._tab.Bytes, x)
            return obj
        return None

    # GenerationConfiguration
    def LorasLength(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(44))
        if o != 0:
            return self._tab.VectorLen(o)
        return 0

    # GenerationConfiguration
    def LorasIsNone(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(44))
        return o == 0

    # GenerationConfiguration
    def MaskBlur(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(46))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
        return 0.0

    # GenerationConfiguration
    def FaceRestoration(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(48))
        if o != 0:
            return self._tab.String(o + self._tab.Pos)
        return None

    # GenerationConfiguration
    def ClipWeight(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(54))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
        return 1.0

    # GenerationConfiguration
    def NegativePromptForImagePrior(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(56))
        if o != 0:
            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
        return True

    # GenerationConfiguration
    def ImagePriorSteps(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(58))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
        return 5

    # GenerationConfiguration
    def RefinerModel(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(60))
        if o != 0:
            return self._tab.String(o + self._tab.Pos)
        return None

    # GenerationConfiguration
    def OriginalImageHeight(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(62))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
        return 0

    # GenerationConfiguration
    def OriginalImageWidth(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(64))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
        return 0

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

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

    # GenerationConfiguration
    def TargetImageHeight(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(70))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
        return 0

    # GenerationConfiguration
    def TargetImageWidth(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(72))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
        return 0

    # GenerationConfiguration
    def AestheticScore(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(74))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
        return 6.0

    # GenerationConfiguration
    def NegativeAestheticScore(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(76))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
        return 2.5

    # GenerationConfiguration
    def ZeroNegativePrompt(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(78))
        if o != 0:
            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
        return False

    # GenerationConfiguration
    def RefinerStart(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(80))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
        return 0.7

    # GenerationConfiguration
    def NegativeOriginalImageHeight(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(82))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
        return 0

    # GenerationConfiguration
    def NegativeOriginalImageWidth(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(84))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
        return 0

    # GenerationConfiguration
    def Name(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(86))
        if o != 0:
            return self._tab.String(o + self._tab.Pos)
        return None

    # GenerationConfiguration
    def FpsId(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(88))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
        return 5

    # GenerationConfiguration
    def MotionBucketId(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(90))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
        return 127

    # GenerationConfiguration
    def CondAug(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(92))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
        return 0.02

    # GenerationConfiguration
    def StartFrameCfg(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(94))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
        return 1.0

    # GenerationConfiguration
    def NumFrames(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(96))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
        return 14

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

    # GenerationConfiguration
    def Sharpness(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(100))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
        return 0.0

    # GenerationConfiguration
    def Shift(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(102))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
        return 1.0

    # GenerationConfiguration
    def Stage2Steps(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(104))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
        return 10

    # GenerationConfiguration
    def Stage2Cfg(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(106))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
        return 1.0

    # GenerationConfiguration
    def Stage2Shift(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(108))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
        return 1.0

    # GenerationConfiguration
    def TiledDecoding(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(110))
        if o != 0:
            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
        return False

    # GenerationConfiguration
    def DecodingTileWidth(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(112))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint16Flags, o + self._tab.Pos)
        return 10

    # GenerationConfiguration
    def DecodingTileHeight(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(114))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint16Flags, o + self._tab.Pos)
        return 10

    # GenerationConfiguration
    def DecodingTileOverlap(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(116))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint16Flags, o + self._tab.Pos)
        return 2

    # GenerationConfiguration
    def StochasticSamplingGamma(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(118))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
        return 0.3

    # GenerationConfiguration
    def PreserveOriginalAfterInpaint(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(120))
        if o != 0:
            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
        return True

    # GenerationConfiguration
    def TiledDiffusion(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(122))
        if o != 0:
            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
        return False

    # GenerationConfiguration
    def DiffusionTileWidth(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(124))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint16Flags, o + self._tab.Pos)
        return 16

    # GenerationConfiguration
    def DiffusionTileHeight(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(126))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint16Flags, o + self._tab.Pos)
        return 16

    # GenerationConfiguration
    def DiffusionTileOverlap(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(128))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint16Flags, o + self._tab.Pos)
        return 2

    # GenerationConfiguration
    def UpscalerScaleFactor(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(130))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
        return 0

    # GenerationConfiguration
    def T5TextEncoder(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(132))
        if o != 0:
            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
        return True

    # GenerationConfiguration
    def SeparateClipL(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(134))
        if o != 0:
            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
        return False

    # GenerationConfiguration
    def ClipLText(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(136))
        if o != 0:
            return self._tab.String(o + self._tab.Pos)
        return None

    # GenerationConfiguration
    def SeparateOpenClipG(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(138))
        if o != 0:
            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
        return False

    # GenerationConfiguration
    def OpenClipGText(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(140))
        if o != 0:
            return self._tab.String(o + self._tab.Pos)
        return None

    # GenerationConfiguration
    def SpeedUpWithGuidanceEmbed(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(142))
        if o != 0:
            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
        return True

    # GenerationConfiguration
    def GuidanceEmbed(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(144))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
        return 3.5

    # GenerationConfiguration
    def ResolutionDependentShift(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(146))
        if o != 0:
            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
        return True

    # GenerationConfiguration
    def TeaCacheStart(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(148))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
        return 5

    # GenerationConfiguration
    def TeaCacheEnd(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(150))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
        return -1

    # GenerationConfiguration
    def TeaCacheThreshold(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(152))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
        return 0.06

    # GenerationConfiguration
    def TeaCache(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(154))
        if o != 0:
            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
        return False

    # GenerationConfiguration
    def SeparateT5(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(156))
        if o != 0:
            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
        return False

    # GenerationConfiguration
    def T5Text(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(158))
        if o != 0:
            return self._tab.String(o + self._tab.Pos)
        return None

    # GenerationConfiguration
    def TeaCacheMaxSkipSteps(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(160))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
        return 3

def GenerationConfigurationStart(builder):
    builder.StartObject(79)

def Start(builder):
    GenerationConfigurationStart(builder)

def GenerationConfigurationAddId(builder, id):
    builder.PrependInt64Slot(0, id, 0)

def AddId(builder, id):
    GenerationConfigurationAddId(builder, id)

def GenerationConfigurationAddStartWidth(builder, startWidth):
    builder.PrependUint16Slot(1, startWidth, 0)

def AddStartWidth(builder, startWidth):
    GenerationConfigurationAddStartWidth(builder, startWidth)

def GenerationConfigurationAddStartHeight(builder, startHeight):
    builder.PrependUint16Slot(2, startHeight, 0)

def AddStartHeight(builder, startHeight):
    GenerationConfigurationAddStartHeight(builder, startHeight)

def GenerationConfigurationAddSeed(builder, seed):
    builder.PrependUint32Slot(3, seed, 0)

def AddSeed(builder, seed):
    GenerationConfigurationAddSeed(builder, seed)

def GenerationConfigurationAddSteps(builder, steps):
    builder.PrependUint32Slot(4, steps, 0)

def AddSteps(builder, steps):
    GenerationConfigurationAddSteps(builder, steps)

def GenerationConfigurationAddGuidanceScale(builder, guidanceScale):
    builder.PrependFloat32Slot(5, guidanceScale, 0.0)

def AddGuidanceScale(builder, guidanceScale):
    GenerationConfigurationAddGuidanceScale(builder, guidanceScale)

def GenerationConfigurationAddStrength(builder, strength):
    builder.PrependFloat32Slot(6, strength, 0.0)

def AddStrength(builder, strength):
    GenerationConfigurationAddStrength(builder, strength)

def GenerationConfigurationAddModel(builder, model):
    builder.PrependUOffsetTRelativeSlot(7, flatbuffers.number_types.UOffsetTFlags.py_type(model), 0)

def AddModel(builder, model):
    GenerationConfigurationAddModel(builder, model)

def GenerationConfigurationAddSampler(builder, sampler):
    builder.PrependInt8Slot(8, sampler, 0)

def AddSampler(builder, sampler):
    GenerationConfigurationAddSampler(builder, sampler)

def GenerationConfigurationAddBatchCount(builder, batchCount):
    builder.PrependUint32Slot(9, batchCount, 1)

def AddBatchCount(builder, batchCount):
    GenerationConfigurationAddBatchCount(builder, batchCount)

def GenerationConfigurationAddBatchSize(builder, batchSize):
    builder.PrependUint32Slot(10, batchSize, 1)

def AddBatchSize(builder, batchSize):
    GenerationConfigurationAddBatchSize(builder, batchSize)

def GenerationConfigurationAddHiresFix(builder, hiresFix):
    builder.PrependBoolSlot(11, hiresFix, 0)

def AddHiresFix(builder, hiresFix):
    GenerationConfigurationAddHiresFix(builder, hiresFix)

def GenerationConfigurationAddHiresFixStartWidth(builder, hiresFixStartWidth):
    builder.PrependUint16Slot(12, hiresFixStartWidth, 0)

def AddHiresFixStartWidth(builder, hiresFixStartWidth):
    GenerationConfigurationAddHiresFixStartWidth(builder, hiresFixStartWidth)

def GenerationConfigurationAddHiresFixStartHeight(builder, hiresFixStartHeight):
    builder.PrependUint16Slot(13, hiresFixStartHeight, 0)

def AddHiresFixStartHeight(builder, hiresFixStartHeight):
    GenerationConfigurationAddHiresFixStartHeight(builder, hiresFixStartHeight)

def GenerationConfigurationAddHiresFixStrength(builder, hiresFixStrength):
    builder.PrependFloat32Slot(14, hiresFixStrength, 0.7)

def AddHiresFixStrength(builder, hiresFixStrength):
    GenerationConfigurationAddHiresFixStrength(builder, hiresFixStrength)

def GenerationConfigurationAddUpscaler(builder, upscaler):
    builder.PrependUOffsetTRelativeSlot(15, flatbuffers.number_types.UOffsetTFlags.py_type(upscaler), 0)

def AddUpscaler(builder, upscaler):
    GenerationConfigurationAddUpscaler(builder, upscaler)

def GenerationConfigurationAddImageGuidanceScale(builder, imageGuidanceScale):
    builder.PrependFloat32Slot(16, imageGuidanceScale, 1.5)

def AddImageGuidanceScale(builder, imageGuidanceScale):
    GenerationConfigurationAddImageGuidanceScale(builder, imageGuidanceScale)

def GenerationConfigurationAddSeedMode(builder, seedMode):
    builder.PrependInt8Slot(17, seedMode, 0)

def AddSeedMode(builder, seedMode):
    GenerationConfigurationAddSeedMode(builder, seedMode)

def GenerationConfigurationAddClipSkip(builder, clipSkip):
    builder.PrependUint32Slot(18, clipSkip, 1)

def AddClipSkip(builder, clipSkip):
    GenerationConfigurationAddClipSkip(builder, clipSkip)

def GenerationConfigurationAddControls(builder, controls):
    builder.PrependUOffsetTRelativeSlot(19, flatbuffers.number_types.UOffsetTFlags.py_type(controls), 0)

def AddControls(builder, controls):
    GenerationConfigurationAddControls(builder, controls)

def GenerationConfigurationStartControlsVector(builder, numElems):
    return builder.StartVector(4, numElems, 4)

def StartControlsVector(builder, numElems):
    return GenerationConfigurationStartControlsVector(builder, numElems)

def GenerationConfigurationAddLoras(builder, loras):
    builder.PrependUOffsetTRelativeSlot(20, flatbuffers.number_types.UOffsetTFlags.py_type(loras), 0)

def AddLoras(builder, loras):
    GenerationConfigurationAddLoras(builder, loras)

def GenerationConfigurationStartLorasVector(builder, numElems):
    return builder.StartVector(4, numElems, 4)

def StartLorasVector(builder, numElems):
    return GenerationConfigurationStartLorasVector(builder, numElems)

def GenerationConfigurationAddMaskBlur(builder, maskBlur):
    builder.PrependFloat32Slot(21, maskBlur, 0.0)

def AddMaskBlur(builder, maskBlur):
    GenerationConfigurationAddMaskBlur(builder, maskBlur)

def GenerationConfigurationAddFaceRestoration(builder, faceRestoration):
    builder.PrependUOffsetTRelativeSlot(22, flatbuffers.number_types.UOffsetTFlags.py_type(faceRestoration), 0)

def AddFaceRestoration(builder, faceRestoration):
    GenerationConfigurationAddFaceRestoration(builder, faceRestoration)

def GenerationConfigurationAddClipWeight(builder, clipWeight):
    builder.PrependFloat32Slot(25, clipWeight, 1.0)

def AddClipWeight(builder, clipWeight):
    GenerationConfigurationAddClipWeight(builder, clipWeight)

def GenerationConfigurationAddNegativePromptForImagePrior(builder, negativePromptForImagePrior):
    builder.PrependBoolSlot(26, negativePromptForImagePrior, 1)

def AddNegativePromptForImagePrior(builder, negativePromptForImagePrior):
    GenerationConfigurationAddNegativePromptForImagePrior(builder, negativePromptForImagePrior)

def GenerationConfigurationAddImagePriorSteps(builder, imagePriorSteps):
    builder.PrependUint32Slot(27, imagePriorSteps, 5)

def AddImagePriorSteps(builder, imagePriorSteps):
    GenerationConfigurationAddImagePriorSteps(builder, imagePriorSteps)

def GenerationConfigurationAddRefinerModel(builder, refinerModel):
    builder.PrependUOffsetTRelativeSlot(28, flatbuffers.number_types.UOffsetTFlags.py_type(refinerModel), 0)

def AddRefinerModel(builder, refinerModel):
    GenerationConfigurationAddRefinerModel(builder, refinerModel)

def GenerationConfigurationAddOriginalImageHeight(builder, originalImageHeight):
    builder.PrependUint32Slot(29, originalImageHeight, 0)

def AddOriginalImageHeight(builder, originalImageHeight):
    GenerationConfigurationAddOriginalImageHeight(builder, originalImageHeight)

def GenerationConfigurationAddOriginalImageWidth(builder, originalImageWidth):
    builder.PrependUint32Slot(30, originalImageWidth, 0)

def AddOriginalImageWidth(builder, originalImageWidth):
    GenerationConfigurationAddOriginalImageWidth(builder, originalImageWidth)

def GenerationConfigurationAddCropTop(builder, cropTop):
    builder.PrependInt32Slot(31, cropTop, 0)

def AddCropTop(builder, cropTop):
    GenerationConfigurationAddCropTop(builder, cropTop)

def GenerationConfigurationAddCropLeft(builder, cropLeft):
    builder.PrependInt32Slot(32, cropLeft, 0)

def AddCropLeft(builder, cropLeft):
    GenerationConfigurationAddCropLeft(builder, cropLeft)

def GenerationConfigurationAddTargetImageHeight(builder, targetImageHeight):
    builder.PrependUint32Slot(33, targetImageHeight, 0)

def AddTargetImageHeight(builder, targetImageHeight):
    GenerationConfigurationAddTargetImageHeight(builder, targetImageHeight)

def GenerationConfigurationAddTargetImageWidth(builder, targetImageWidth):
    builder.PrependUint32Slot(34, targetImageWidth, 0)

def AddTargetImageWidth(builder, targetImageWidth):
    GenerationConfigurationAddTargetImageWidth(builder, targetImageWidth)

def GenerationConfigurationAddAestheticScore(builder, aestheticScore):
    builder.PrependFloat32Slot(35, aestheticScore, 6.0)

def AddAestheticScore(builder, aestheticScore):
    GenerationConfigurationAddAestheticScore(builder, aestheticScore)

def GenerationConfigurationAddNegativeAestheticScore(builder, negativeAestheticScore):
    builder.PrependFloat32Slot(36, negativeAestheticScore, 2.5)

def AddNegativeAestheticScore(builder, negativeAestheticScore):
    GenerationConfigurationAddNegativeAestheticScore(builder, negativeAestheticScore)

def GenerationConfigurationAddZeroNegativePrompt(builder, zeroNegativePrompt):
    builder.PrependBoolSlot(37, zeroNegativePrompt, 0)

def AddZeroNegativePrompt(builder, zeroNegativePrompt):
    GenerationConfigurationAddZeroNegativePrompt(builder, zeroNegativePrompt)

def GenerationConfigurationAddRefinerStart(builder, refinerStart):
    builder.PrependFloat32Slot(38, refinerStart, 0.7)

def AddRefinerStart(builder, refinerStart):
    GenerationConfigurationAddRefinerStart(builder, refinerStart)

def GenerationConfigurationAddNegativeOriginalImageHeight(builder, negativeOriginalImageHeight):
    builder.PrependUint32Slot(39, negativeOriginalImageHeight, 0)

def AddNegativeOriginalImageHeight(builder, negativeOriginalImageHeight):
    GenerationConfigurationAddNegativeOriginalImageHeight(builder, negativeOriginalImageHeight)

def GenerationConfigurationAddNegativeOriginalImageWidth(builder, negativeOriginalImageWidth):
    builder.PrependUint32Slot(40, negativeOriginalImageWidth, 0)

def AddNegativeOriginalImageWidth(builder, negativeOriginalImageWidth):
    GenerationConfigurationAddNegativeOriginalImageWidth(builder, negativeOriginalImageWidth)

def GenerationConfigurationAddName(builder, name):
    builder.PrependUOffsetTRelativeSlot(41, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0)

def AddName(builder, name):
    GenerationConfigurationAddName(builder, name)

def GenerationConfigurationAddFpsId(builder, fpsId):
    builder.PrependUint32Slot(42, fpsId, 5)

def AddFpsId(builder, fpsId):
    GenerationConfigurationAddFpsId(builder, fpsId)

def GenerationConfigurationAddMotionBucketId(builder, motionBucketId):
    builder.PrependUint32Slot(43, motionBucketId, 127)

def AddMotionBucketId(builder, motionBucketId):
    GenerationConfigurationAddMotionBucketId(builder, motionBucketId)

def GenerationConfigurationAddCondAug(builder, condAug):
    builder.PrependFloat32Slot(44, condAug, 0.02)

def AddCondAug(builder, condAug):
    GenerationConfigurationAddCondAug(builder, condAug)

def GenerationConfigurationAddStartFrameCfg(builder, startFrameCfg):
    builder.PrependFloat32Slot(45, startFrameCfg, 1.0)

def AddStartFrameCfg(builder, startFrameCfg):
    GenerationConfigurationAddStartFrameCfg(builder, startFrameCfg)

def GenerationConfigurationAddNumFrames(builder, numFrames):
    builder.PrependUint32Slot(46, numFrames, 14)

def AddNumFrames(builder, numFrames):
    GenerationConfigurationAddNumFrames(builder, numFrames)

def GenerationConfigurationAddMaskBlurOutset(builder, maskBlurOutset):
    builder.PrependInt32Slot(47, maskBlurOutset, 0)

def AddMaskBlurOutset(builder, maskBlurOutset):
    GenerationConfigurationAddMaskBlurOutset(builder, maskBlurOutset)

def GenerationConfigurationAddSharpness(builder, sharpness):
    builder.PrependFloat32Slot(48, sharpness, 0.0)

def AddSharpness(builder, sharpness):
    GenerationConfigurationAddSharpness(builder, sharpness)

def GenerationConfigurationAddShift(builder, shift):
    builder.PrependFloat32Slot(49, shift, 1.0)

def AddShift(builder, shift):
    GenerationConfigurationAddShift(builder, shift)

def GenerationConfigurationAddStage2Steps(builder, stage2Steps):
    builder.PrependUint32Slot(50, stage2Steps, 10)

def AddStage2Steps(builder, stage2Steps):
    GenerationConfigurationAddStage2Steps(builder, stage2Steps)

def GenerationConfigurationAddStage2Cfg(builder, stage2Cfg):
    builder.PrependFloat32Slot(51, stage2Cfg, 1.0)

def AddStage2Cfg(builder, stage2Cfg):
    GenerationConfigurationAddStage2Cfg(builder, stage2Cfg)

def GenerationConfigurationAddStage2Shift(builder, stage2Shift):
    builder.PrependFloat32Slot(52, stage2Shift, 1.0)

def AddStage2Shift(builder, stage2Shift):
    GenerationConfigurationAddStage2Shift(builder, stage2Shift)

def GenerationConfigurationAddTiledDecoding(builder, tiledDecoding):
    builder.PrependBoolSlot(53, tiledDecoding, 0)

def AddTiledDecoding(builder, tiledDecoding):
    GenerationConfigurationAddTiledDecoding(builder, tiledDecoding)

def GenerationConfigurationAddDecodingTileWidth(builder, decodingTileWidth):
    builder.PrependUint16Slot(54, decodingTileWidth, 10)

def AddDecodingTileWidth(builder, decodingTileWidth):
    GenerationConfigurationAddDecodingTileWidth(builder, decodingTileWidth)

def GenerationConfigurationAddDecodingTileHeight(builder, decodingTileHeight):
    builder.PrependUint16Slot(55, decodingTileHeight, 10)

def AddDecodingTileHeight(builder, decodingTileHeight):
    GenerationConfigurationAddDecodingTileHeight(builder, decodingTileHeight)

def GenerationConfigurationAddDecodingTileOverlap(builder, decodingTileOverlap):
    builder.PrependUint16Slot(56, decodingTileOverlap, 2)

def AddDecodingTileOverlap(builder, decodingTileOverlap):
    GenerationConfigurationAddDecodingTileOverlap(builder, decodingTileOverlap)

def GenerationConfigurationAddStochasticSamplingGamma(builder, stochasticSamplingGamma):
    builder.PrependFloat32Slot(57, stochasticSamplingGamma, 0.3)

def AddStochasticSamplingGamma(builder, stochasticSamplingGamma):
    GenerationConfigurationAddStochasticSamplingGamma(builder, stochasticSamplingGamma)

def GenerationConfigurationAddPreserveOriginalAfterInpaint(builder, preserveOriginalAfterInpaint):
    builder.PrependBoolSlot(58, preserveOriginalAfterInpaint, 1)

def AddPreserveOriginalAfterInpaint(builder, preserveOriginalAfterInpaint):
    GenerationConfigurationAddPreserveOriginalAfterInpaint(builder, preserveOriginalAfterInpaint)

def GenerationConfigurationAddTiledDiffusion(builder, tiledDiffusion):
    builder.PrependBoolSlot(59, tiledDiffusion, 0)

def AddTiledDiffusion(builder, tiledDiffusion):
    GenerationConfigurationAddTiledDiffusion(builder, tiledDiffusion)

def GenerationConfigurationAddDiffusionTileWidth(builder, diffusionTileWidth):
    builder.PrependUint16Slot(60, diffusionTileWidth, 16)

def AddDiffusionTileWidth(builder, diffusionTileWidth):
    GenerationConfigurationAddDiffusionTileWidth(builder, diffusionTileWidth)

def GenerationConfigurationAddDiffusionTileHeight(builder, diffusionTileHeight):
    builder.PrependUint16Slot(61, diffusionTileHeight, 16)

def AddDiffusionTileHeight(builder, diffusionTileHeight):
    GenerationConfigurationAddDiffusionTileHeight(builder, diffusionTileHeight)

def GenerationConfigurationAddDiffusionTileOverlap(builder, diffusionTileOverlap):
    builder.PrependUint16Slot(62, diffusionTileOverlap, 2)

def AddDiffusionTileOverlap(builder, diffusionTileOverlap):
    GenerationConfigurationAddDiffusionTileOverlap(builder, diffusionTileOverlap)

def GenerationConfigurationAddUpscalerScaleFactor(builder, upscalerScaleFactor):
    builder.PrependUint8Slot(63, upscalerScaleFactor, 0)

def AddUpscalerScaleFactor(builder, upscalerScaleFactor):
    GenerationConfigurationAddUpscalerScaleFactor(builder, upscalerScaleFactor)

def GenerationConfigurationAddT5TextEncoder(builder, t5TextEncoder):
    builder.PrependBoolSlot(64, t5TextEncoder, 1)

def AddT5TextEncoder(builder, t5TextEncoder):
    GenerationConfigurationAddT5TextEncoder(builder, t5TextEncoder)

def GenerationConfigurationAddSeparateClipL(builder, separateClipL):
    builder.PrependBoolSlot(65, separateClipL, 0)

def AddSeparateClipL(builder, separateClipL):
    GenerationConfigurationAddSeparateClipL(builder, separateClipL)

def GenerationConfigurationAddClipLText(builder, clipLText):
    builder.PrependUOffsetTRelativeSlot(66, flatbuffers.number_types.UOffsetTFlags.py_type(clipLText), 0)

def AddClipLText(builder, clipLText):
    GenerationConfigurationAddClipLText(builder, clipLText)

def GenerationConfigurationAddSeparateOpenClipG(builder, separateOpenClipG):
    builder.PrependBoolSlot(67, separateOpenClipG, 0)

def AddSeparateOpenClipG(builder, separateOpenClipG):
    GenerationConfigurationAddSeparateOpenClipG(builder, separateOpenClipG)

def GenerationConfigurationAddOpenClipGText(builder, openClipGText):
    builder.PrependUOffsetTRelativeSlot(68, flatbuffers.number_types.UOffsetTFlags.py_type(openClipGText), 0)

def AddOpenClipGText(builder, openClipGText):
    GenerationConfigurationAddOpenClipGText(builder, openClipGText)

def GenerationConfigurationAddSpeedUpWithGuidanceEmbed(builder, speedUpWithGuidanceEmbed):
    builder.PrependBoolSlot(69, speedUpWithGuidanceEmbed, 1)

def AddSpeedUpWithGuidanceEmbed(builder, speedUpWithGuidanceEmbed):
    GenerationConfigurationAddSpeedUpWithGuidanceEmbed(builder, speedUpWithGuidanceEmbed)

def GenerationConfigurationAddGuidanceEmbed(builder, guidanceEmbed):
    builder.PrependFloat32Slot(70, guidanceEmbed, 3.5)

def AddGuidanceEmbed(builder, guidanceEmbed):
    GenerationConfigurationAddGuidanceEmbed(builder, guidanceEmbed)

def GenerationConfigurationAddResolutionDependentShift(builder, resolutionDependentShift):
    builder.PrependBoolSlot(71, resolutionDependentShift, 1)

def AddResolutionDependentShift(builder, resolutionDependentShift):
    GenerationConfigurationAddResolutionDependentShift(builder, resolutionDependentShift)

def GenerationConfigurationAddTeaCacheStart(builder, teaCacheStart):
    builder.PrependInt32Slot(72, teaCacheStart, 5)

def AddTeaCacheStart(builder, teaCacheStart):
    GenerationConfigurationAddTeaCacheStart(builder, teaCacheStart)

def GenerationConfigurationAddTeaCacheEnd(builder, teaCacheEnd):
    builder.PrependInt32Slot(73, teaCacheEnd, -1)

def AddTeaCacheEnd(builder, teaCacheEnd):
    GenerationConfigurationAddTeaCacheEnd(builder, teaCacheEnd)

def GenerationConfigurationAddTeaCacheThreshold(builder, teaCacheThreshold):
    builder.PrependFloat32Slot(74, teaCacheThreshold, 0.06)

def AddTeaCacheThreshold(builder, teaCacheThreshold):
    GenerationConfigurationAddTeaCacheThreshold(builder, teaCacheThreshold)

def GenerationConfigurationAddTeaCache(builder, teaCache):
    builder.PrependBoolSlot(75, teaCache, 0)

def AddTeaCache(builder, teaCache):
    GenerationConfigurationAddTeaCache(builder, teaCache)

def GenerationConfigurationAddSeparateT5(builder, separateT5):
    builder.PrependBoolSlot(76, separateT5, 0)

def AddSeparateT5(builder, separateT5):
    GenerationConfigurationAddSeparateT5(builder, separateT5)

def GenerationConfigurationAddT5Text(builder, t5Text):
    builder.PrependUOffsetTRelativeSlot(77, flatbuffers.number_types.UOffsetTFlags.py_type(t5Text), 0)

def AddT5Text(builder, t5Text):
    GenerationConfigurationAddT5Text(builder, t5Text)

def GenerationConfigurationAddTeaCacheMaxSkipSteps(builder, teaCacheMaxSkipSteps):
    builder.PrependInt32Slot(78, teaCacheMaxSkipSteps, 3)

def AddTeaCacheMaxSkipSteps(builder, teaCacheMaxSkipSteps):
    GenerationConfigurationAddTeaCacheMaxSkipSteps(builder, teaCacheMaxSkipSteps)

def GenerationConfigurationEnd(builder):
    return builder.EndObject()

def End(builder):
    return GenerationConfigurationEnd(builder)