types.go

// @generated by Thrift for [[[ program path ]]]
// This file is probably not the place you want to edit!

package thrift // [[[ program thrift source path ]]]

import (
  "fmt"

  scope "thrift/annotation/scope"
  "github.com/facebook/fbthrift/thrift/lib/go/thrift"
)

var _ = scope.GoUnusedProtection__

// (needed to ensure safety because of naive import list construction)
var _ = fmt.Printf
var _ = thrift.ZERO


type Beta struct {
}
// Compile time interface enforcer
var _ thrift.Struct = &Beta{}

func NewBeta() *Beta {
    return (&Beta{})
}

// Deprecated: Use Beta.Set* methods instead or set the fields directly.
type BetaBuilder struct {
    obj *Beta
}

func NewBetaBuilder() *BetaBuilder {
    return &BetaBuilder{
        obj: NewBeta(),
    }
}

func (x *BetaBuilder) Emit() *Beta {
    var objCopy Beta = *x.obj
    return &objCopy
}

func (x *Beta) Write(p thrift.Protocol) error {
    if err := p.WriteStructBegin("Beta"); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", x), err)
    }

    if err := p.WriteFieldStop(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", x), err)
    }

    if err := p.WriteStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", x), err)
    }
    return nil
}

func (x *Beta) Read(p thrift.Protocol) error {
    if _, err := p.ReadStructBegin(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read error: ", x), err)
    }

    for {
        _, typ, id, err := p.ReadFieldBegin()
        if err != nil {
            return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", x, id), err)
        }

        if typ == thrift.STOP {
            break;
        }

        switch id {
        default:
            if err := p.Skip(typ); err != nil {
                return err
            }
        }

        if err := p.ReadFieldEnd(); err != nil {
            return err
        }
    }

    if err := p.ReadStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", x), err)
    }

    return nil
}

type Experimental struct {
}
// Compile time interface enforcer
var _ thrift.Struct = &Experimental{}

func NewExperimental() *Experimental {
    return (&Experimental{})
}

// Deprecated: Use Experimental.Set* methods instead or set the fields directly.
type ExperimentalBuilder struct {
    obj *Experimental
}

func NewExperimentalBuilder() *ExperimentalBuilder {
    return &ExperimentalBuilder{
        obj: NewExperimental(),
    }
}

func (x *ExperimentalBuilder) Emit() *Experimental {
    var objCopy Experimental = *x.obj
    return &objCopy
}

func (x *Experimental) Write(p thrift.Protocol) error {
    if err := p.WriteStructBegin("Experimental"); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", x), err)
    }

    if err := p.WriteFieldStop(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", x), err)
    }

    if err := p.WriteStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", x), err)
    }
    return nil
}

func (x *Experimental) Read(p thrift.Protocol) error {
    if _, err := p.ReadStructBegin(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read error: ", x), err)
    }

    for {
        _, typ, id, err := p.ReadFieldBegin()
        if err != nil {
            return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", x, id), err)
        }

        if typ == thrift.STOP {
            break;
        }

        switch id {
        default:
            if err := p.Skip(typ); err != nil {
                return err
            }
        }

        if err := p.ReadFieldEnd(); err != nil {
            return err
        }
    }

    if err := p.ReadStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", x), err)
    }

    return nil
}

type Testing struct {
}
// Compile time interface enforcer
var _ thrift.Struct = &Testing{}

func NewTesting() *Testing {
    return (&Testing{})
}

// Deprecated: Use Testing.Set* methods instead or set the fields directly.
type TestingBuilder struct {
    obj *Testing
}

func NewTestingBuilder() *TestingBuilder {
    return &TestingBuilder{
        obj: NewTesting(),
    }
}

func (x *TestingBuilder) Emit() *Testing {
    var objCopy Testing = *x.obj
    return &objCopy
}

func (x *Testing) Write(p thrift.Protocol) error {
    if err := p.WriteStructBegin("Testing"); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", x), err)
    }

    if err := p.WriteFieldStop(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", x), err)
    }

    if err := p.WriteStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", x), err)
    }
    return nil
}

func (x *Testing) Read(p thrift.Protocol) error {
    if _, err := p.ReadStructBegin(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read error: ", x), err)
    }

    for {
        _, typ, id, err := p.ReadFieldBegin()
        if err != nil {
            return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", x, id), err)
        }

        if typ == thrift.STOP {
            break;
        }

        switch id {
        default:
            if err := p.Skip(typ); err != nil {
                return err
            }
        }

        if err := p.ReadFieldEnd(); err != nil {
            return err
        }
    }

    if err := p.ReadStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", x), err)
    }

    return nil
}

type Deprecated struct {
    Message string `thrift:"message,1" json:"message" db:"message"`
}
// Compile time interface enforcer
var _ thrift.Struct = &Deprecated{}

func NewDeprecated() *Deprecated {
    return (&Deprecated{})
}
func (x *Deprecated) GetMessage() string {
    return x.Message
}

func (x *Deprecated) SetMessage(value string) *Deprecated {
    x.Message = value
    return x
}


func (x *Deprecated) writeField1(p thrift.Protocol) error {  // Message
    if err := p.WriteFieldBegin("message", thrift.STRING, 1); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field begin error: ", x), err)
    }

    item := x.GetMessage()
    if err := p.WriteString(item); err != nil {
    return err
}

    if err := p.WriteFieldEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field end error: ", x), err)
    }
    return nil
}

func (x *Deprecated) readField1(p thrift.Protocol) error {  // Message
    result, err := p.ReadString()
if err != nil {
    return err
}

    x.SetMessage(result)
    return nil
}


// Deprecated: Use Deprecated.Set* methods instead or set the fields directly.
type DeprecatedBuilder struct {
    obj *Deprecated
}

func NewDeprecatedBuilder() *DeprecatedBuilder {
    return &DeprecatedBuilder{
        obj: NewDeprecated(),
    }
}

func (x *DeprecatedBuilder) Message(value string) *DeprecatedBuilder {
    x.obj.Message = value
    return x
}

func (x *DeprecatedBuilder) Emit() *Deprecated {
    var objCopy Deprecated = *x.obj
    return &objCopy
}

func (x *Deprecated) Write(p thrift.Protocol) error {
    if err := p.WriteStructBegin("Deprecated"); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", x), err)
    }

    if err := x.writeField1(p); err != nil {
        return err
    }

    if err := p.WriteFieldStop(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", x), err)
    }

    if err := p.WriteStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", x), err)
    }
    return nil
}

func (x *Deprecated) Read(p thrift.Protocol) error {
    if _, err := p.ReadStructBegin(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read error: ", x), err)
    }

    for {
        _, typ, id, err := p.ReadFieldBegin()
        if err != nil {
            return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", x, id), err)
        }

        if typ == thrift.STOP {
            break;
        }

        switch id {
        case 1:  // message
            if err := x.readField1(p); err != nil {
                return err
            }
        default:
            if err := p.Skip(typ); err != nil {
                return err
            }
        }

        if err := p.ReadFieldEnd(); err != nil {
            return err
        }
    }

    if err := p.ReadStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", x), err)
    }

    return nil
}

type ReserveIds struct {
    Ids []int32 `thrift:"ids,1" json:"ids" db:"ids"`
    IdRanges map[int32]int32 `thrift:"id_ranges,2" json:"id_ranges" db:"id_ranges"`
}
// Compile time interface enforcer
var _ thrift.Struct = &ReserveIds{}

func NewReserveIds() *ReserveIds {
    return (&ReserveIds{})
}
func (x *ReserveIds) GetIds() []int32 {
    return x.Ids
}

func (x *ReserveIds) GetIdRanges() map[int32]int32 {
    return x.IdRanges
}

func (x *ReserveIds) SetIds(value []int32) *ReserveIds {
    x.Ids = value
    return x
}

func (x *ReserveIds) SetIdRanges(value map[int32]int32) *ReserveIds {
    x.IdRanges = value
    return x
}

func (x *ReserveIds) IsSetIds() bool {
    return x.Ids != nil
}

func (x *ReserveIds) IsSetIdRanges() bool {
    return x.IdRanges != nil
}

func (x *ReserveIds) writeField1(p thrift.Protocol) error {  // Ids
    if !x.IsSetIds() {
        return nil
    }

    if err := p.WriteFieldBegin("ids", thrift.LIST, 1); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field begin error: ", x), err)
    }

    item := x.GetIds()
    if err := p.WriteListBegin(thrift.I32, len(item)); err != nil {
    return thrift.PrependError("error writing list begin: ", err)
}
for _, v := range item {
    {
        item := v
        if err := p.WriteI32(item); err != nil {
    return err
}
    }
}
if err := p.WriteListEnd(); err != nil {
    return thrift.PrependError("error writing list end: ", err)
}

    if err := p.WriteFieldEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field end error: ", x), err)
    }
    return nil
}

func (x *ReserveIds) writeField2(p thrift.Protocol) error {  // IdRanges
    if !x.IsSetIdRanges() {
        return nil
    }

    if err := p.WriteFieldBegin("id_ranges", thrift.MAP, 2); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field begin error: ", x), err)
    }

    item := x.GetIdRanges()
    if err := p.WriteMapBegin(thrift.I32, thrift.I32, len(item)); err != nil {
    return thrift.PrependError("error writing map begin: ", err)
}
for k, v := range item {
    {
        item := k
        if err := p.WriteI32(item); err != nil {
    return err
}
    }

    {
        item := v
        if err := p.WriteI32(item); err != nil {
    return err
}
    }
}
if err := p.WriteMapEnd(); err != nil {
    return thrift.PrependError("error writing map end: ", err)
}

    if err := p.WriteFieldEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field end error: ", x), err)
    }
    return nil
}

func (x *ReserveIds) readField1(p thrift.Protocol) error {  // Ids
    _ /* elemType */, size, err := p.ReadListBegin()
if err != nil {
    return thrift.PrependError("error reading list begin: ", err)
}

listResult := make([]int32, 0, size)
for i := 0; i < size; i++ {
    var elem int32
    {
        result, err := p.ReadI32()
if err != nil {
    return err
}
        elem = result
    }
    listResult = append(listResult, elem)
}

if err := p.ReadListEnd(); err != nil {
    return thrift.PrependError("error reading list end: ", err)
}
result := listResult

    x.SetIds(result)
    return nil
}

func (x *ReserveIds) readField2(p thrift.Protocol) error {  // IdRanges
    _ /* keyType */, _ /* valueType */, size, err := p.ReadMapBegin()
if err != nil {
    return thrift.PrependError("error reading map begin: ", err)
}

mapResult := make(map[int32]int32, size)
for i := 0; i < size; i++ {
    var key int32
    {
        result, err := p.ReadI32()
if err != nil {
    return err
}
        key = result
    }

    var value int32
    {
        result, err := p.ReadI32()
if err != nil {
    return err
}
        value = result
    }

    mapResult[key] = value
}

if err := p.ReadMapEnd(); err != nil {
    return thrift.PrependError("error reading map end: ", err)
}
result := mapResult

    x.SetIdRanges(result)
    return nil
}


// Deprecated: Use ReserveIds.Set* methods instead or set the fields directly.
type ReserveIdsBuilder struct {
    obj *ReserveIds
}

func NewReserveIdsBuilder() *ReserveIdsBuilder {
    return &ReserveIdsBuilder{
        obj: NewReserveIds(),
    }
}

func (x *ReserveIdsBuilder) Ids(value []int32) *ReserveIdsBuilder {
    x.obj.Ids = value
    return x
}

func (x *ReserveIdsBuilder) IdRanges(value map[int32]int32) *ReserveIdsBuilder {
    x.obj.IdRanges = value
    return x
}

func (x *ReserveIdsBuilder) Emit() *ReserveIds {
    var objCopy ReserveIds = *x.obj
    return &objCopy
}

func (x *ReserveIds) Write(p thrift.Protocol) error {
    if err := p.WriteStructBegin("ReserveIds"); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", x), err)
    }

    if err := x.writeField1(p); err != nil {
        return err
    }

    if err := x.writeField2(p); err != nil {
        return err
    }

    if err := p.WriteFieldStop(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", x), err)
    }

    if err := p.WriteStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", x), err)
    }
    return nil
}

func (x *ReserveIds) Read(p thrift.Protocol) error {
    if _, err := p.ReadStructBegin(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read error: ", x), err)
    }

    for {
        _, typ, id, err := p.ReadFieldBegin()
        if err != nil {
            return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", x, id), err)
        }

        if typ == thrift.STOP {
            break;
        }

        switch id {
        case 1:  // ids
            if err := x.readField1(p); err != nil {
                return err
            }
        case 2:  // id_ranges
            if err := x.readField2(p); err != nil {
                return err
            }
        default:
            if err := p.Skip(typ); err != nil {
                return err
            }
        }

        if err := p.ReadFieldEnd(); err != nil {
            return err
        }
    }

    if err := p.ReadStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", x), err)
    }

    return nil
}

type Legacy struct {
    Message string `thrift:"message,1" json:"message" db:"message"`
}
// Compile time interface enforcer
var _ thrift.Struct = &Legacy{}

func NewLegacy() *Legacy {
    return (&Legacy{})
}
func (x *Legacy) GetMessage() string {
    return x.Message
}

func (x *Legacy) SetMessage(value string) *Legacy {
    x.Message = value
    return x
}


func (x *Legacy) writeField1(p thrift.Protocol) error {  // Message
    if err := p.WriteFieldBegin("message", thrift.STRING, 1); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field begin error: ", x), err)
    }

    item := x.GetMessage()
    if err := p.WriteString(item); err != nil {
    return err
}

    if err := p.WriteFieldEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field end error: ", x), err)
    }
    return nil
}

func (x *Legacy) readField1(p thrift.Protocol) error {  // Message
    result, err := p.ReadString()
if err != nil {
    return err
}

    x.SetMessage(result)
    return nil
}


// Deprecated: Use Legacy.Set* methods instead or set the fields directly.
type LegacyBuilder struct {
    obj *Legacy
}

func NewLegacyBuilder() *LegacyBuilder {
    return &LegacyBuilder{
        obj: NewLegacy(),
    }
}

func (x *LegacyBuilder) Message(value string) *LegacyBuilder {
    x.obj.Message = value
    return x
}

func (x *LegacyBuilder) Emit() *Legacy {
    var objCopy Legacy = *x.obj
    return &objCopy
}

func (x *Legacy) Write(p thrift.Protocol) error {
    if err := p.WriteStructBegin("Legacy"); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", x), err)
    }

    if err := x.writeField1(p); err != nil {
        return err
    }

    if err := p.WriteFieldStop(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", x), err)
    }

    if err := p.WriteStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", x), err)
    }
    return nil
}

func (x *Legacy) Read(p thrift.Protocol) error {
    if _, err := p.ReadStructBegin(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read error: ", x), err)
    }

    for {
        _, typ, id, err := p.ReadFieldBegin()
        if err != nil {
            return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", x, id), err)
        }

        if typ == thrift.STOP {
            break;
        }

        switch id {
        case 1:  // message
            if err := x.readField1(p); err != nil {
                return err
            }
        default:
            if err := p.Skip(typ); err != nil {
                return err
            }
        }

        if err := p.ReadFieldEnd(); err != nil {
            return err
        }
    }

    if err := p.ReadStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", x), err)
    }

    return nil
}

type RequiresBackwardCompatibility struct {
    FieldName bool `thrift:"field_name,1" json:"field_name" db:"field_name"`
}
// Compile time interface enforcer
var _ thrift.Struct = &RequiresBackwardCompatibility{}

func NewRequiresBackwardCompatibility() *RequiresBackwardCompatibility {
    return (&RequiresBackwardCompatibility{}).
        SetFieldName(false)
}
func (x *RequiresBackwardCompatibility) GetFieldName() bool {
    return x.FieldName
}

func (x *RequiresBackwardCompatibility) SetFieldName(value bool) *RequiresBackwardCompatibility {
    x.FieldName = value
    return x
}


func (x *RequiresBackwardCompatibility) writeField1(p thrift.Protocol) error {  // FieldName
    if err := p.WriteFieldBegin("field_name", thrift.BOOL, 1); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field begin error: ", x), err)
    }

    item := x.GetFieldName()
    if err := p.WriteBool(item); err != nil {
    return err
}

    if err := p.WriteFieldEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field end error: ", x), err)
    }
    return nil
}

func (x *RequiresBackwardCompatibility) readField1(p thrift.Protocol) error {  // FieldName
    result, err := p.ReadBool()
if err != nil {
    return err
}

    x.SetFieldName(result)
    return nil
}


// Deprecated: Use RequiresBackwardCompatibility.Set* methods instead or set the fields directly.
type RequiresBackwardCompatibilityBuilder struct {
    obj *RequiresBackwardCompatibility
}

func NewRequiresBackwardCompatibilityBuilder() *RequiresBackwardCompatibilityBuilder {
    return &RequiresBackwardCompatibilityBuilder{
        obj: NewRequiresBackwardCompatibility(),
    }
}

func (x *RequiresBackwardCompatibilityBuilder) FieldName(value bool) *RequiresBackwardCompatibilityBuilder {
    x.obj.FieldName = value
    return x
}

func (x *RequiresBackwardCompatibilityBuilder) Emit() *RequiresBackwardCompatibility {
    var objCopy RequiresBackwardCompatibility = *x.obj
    return &objCopy
}

func (x *RequiresBackwardCompatibility) Write(p thrift.Protocol) error {
    if err := p.WriteStructBegin("RequiresBackwardCompatibility"); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", x), err)
    }

    if err := x.writeField1(p); err != nil {
        return err
    }

    if err := p.WriteFieldStop(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", x), err)
    }

    if err := p.WriteStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", x), err)
    }
    return nil
}

func (x *RequiresBackwardCompatibility) Read(p thrift.Protocol) error {
    if _, err := p.ReadStructBegin(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read error: ", x), err)
    }

    for {
        _, typ, id, err := p.ReadFieldBegin()
        if err != nil {
            return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", x, id), err)
        }

        if typ == thrift.STOP {
            break;
        }

        switch id {
        case 1:  // field_name
            if err := x.readField1(p); err != nil {
                return err
            }
        default:
            if err := p.Skip(typ); err != nil {
                return err
            }
        }

        if err := p.ReadFieldEnd(); err != nil {
            return err
        }
    }

    if err := p.ReadStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", x), err)
    }

    return nil
}

type NoTesting struct {
}
// Compile time interface enforcer
var _ thrift.Struct = &NoTesting{}

func NewNoTesting() *NoTesting {
    return (&NoTesting{})
}

// Deprecated: Use NoTesting.Set* methods instead or set the fields directly.
type NoTestingBuilder struct {
    obj *NoTesting
}

func NewNoTestingBuilder() *NoTestingBuilder {
    return &NoTestingBuilder{
        obj: NewNoTesting(),
    }
}

func (x *NoTestingBuilder) Emit() *NoTesting {
    var objCopy NoTesting = *x.obj
    return &objCopy
}

func (x *NoTesting) Write(p thrift.Protocol) error {
    if err := p.WriteStructBegin("NoTesting"); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", x), err)
    }

    if err := p.WriteFieldStop(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", x), err)
    }

    if err := p.WriteStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", x), err)
    }
    return nil
}

func (x *NoTesting) Read(p thrift.Protocol) error {
    if _, err := p.ReadStructBegin(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read error: ", x), err)
    }

    for {
        _, typ, id, err := p.ReadFieldBegin()
        if err != nil {
            return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", x, id), err)
        }

        if typ == thrift.STOP {
            break;
        }

        switch id {
        default:
            if err := p.Skip(typ); err != nil {
                return err
            }
        }

        if err := p.ReadFieldEnd(); err != nil {
            return err
        }
    }

    if err := p.ReadStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", x), err)
    }

    return nil
}

type NoExperimental struct {
}
// Compile time interface enforcer
var _ thrift.Struct = &NoExperimental{}

func NewNoExperimental() *NoExperimental {
    return (&NoExperimental{})
}

// Deprecated: Use NoExperimental.Set* methods instead or set the fields directly.
type NoExperimentalBuilder struct {
    obj *NoExperimental
}

func NewNoExperimentalBuilder() *NoExperimentalBuilder {
    return &NoExperimentalBuilder{
        obj: NewNoExperimental(),
    }
}

func (x *NoExperimentalBuilder) Emit() *NoExperimental {
    var objCopy NoExperimental = *x.obj
    return &objCopy
}

func (x *NoExperimental) Write(p thrift.Protocol) error {
    if err := p.WriteStructBegin("NoExperimental"); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", x), err)
    }

    if err := p.WriteFieldStop(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", x), err)
    }

    if err := p.WriteStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", x), err)
    }
    return nil
}

func (x *NoExperimental) Read(p thrift.Protocol) error {
    if _, err := p.ReadStructBegin(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read error: ", x), err)
    }

    for {
        _, typ, id, err := p.ReadFieldBegin()
        if err != nil {
            return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", x, id), err)
        }

        if typ == thrift.STOP {
            break;
        }

        switch id {
        default:
            if err := p.Skip(typ); err != nil {
                return err
            }
        }

        if err := p.ReadFieldEnd(); err != nil {
            return err
        }
    }

    if err := p.ReadStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", x), err)
    }

    return nil
}

type NoBeta struct {
}
// Compile time interface enforcer
var _ thrift.Struct = &NoBeta{}

func NewNoBeta() *NoBeta {
    return (&NoBeta{})
}

// Deprecated: Use NoBeta.Set* methods instead or set the fields directly.
type NoBetaBuilder struct {
    obj *NoBeta
}

func NewNoBetaBuilder() *NoBetaBuilder {
    return &NoBetaBuilder{
        obj: NewNoBeta(),
    }
}

func (x *NoBetaBuilder) Emit() *NoBeta {
    var objCopy NoBeta = *x.obj
    return &objCopy
}

func (x *NoBeta) Write(p thrift.Protocol) error {
    if err := p.WriteStructBegin("NoBeta"); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", x), err)
    }

    if err := p.WriteFieldStop(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", x), err)
    }

    if err := p.WriteStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", x), err)
    }
    return nil
}

func (x *NoBeta) Read(p thrift.Protocol) error {
    if _, err := p.ReadStructBegin(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read error: ", x), err)
    }

    for {
        _, typ, id, err := p.ReadFieldBegin()
        if err != nil {
            return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", x, id), err)
        }

        if typ == thrift.STOP {
            break;
        }

        switch id {
        default:
            if err := p.Skip(typ); err != nil {
                return err
            }
        }

        if err := p.ReadFieldEnd(); err != nil {
            return err
        }
    }

    if err := p.ReadStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", x), err)
    }

    return nil
}

type Released struct {
}
// Compile time interface enforcer
var _ thrift.Struct = &Released{}

func NewReleased() *Released {
    return (&Released{})
}

// Deprecated: Use Released.Set* methods instead or set the fields directly.
type ReleasedBuilder struct {
    obj *Released
}

func NewReleasedBuilder() *ReleasedBuilder {
    return &ReleasedBuilder{
        obj: NewReleased(),
    }
}

func (x *ReleasedBuilder) Emit() *Released {
    var objCopy Released = *x.obj
    return &objCopy
}

func (x *Released) Write(p thrift.Protocol) error {
    if err := p.WriteStructBegin("Released"); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", x), err)
    }

    if err := p.WriteFieldStop(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", x), err)
    }

    if err := p.WriteStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", x), err)
    }
    return nil
}

func (x *Released) Read(p thrift.Protocol) error {
    if _, err := p.ReadStructBegin(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read error: ", x), err)
    }

    for {
        _, typ, id, err := p.ReadFieldBegin()
        if err != nil {
            return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", x, id), err)
        }

        if typ == thrift.STOP {
            break;
        }

        switch id {
        default:
            if err := p.Skip(typ); err != nil {
                return err
            }
        }

        if err := p.ReadFieldEnd(); err != nil {
            return err
        }
    }

    if err := p.ReadStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", x), err)
    }

    return nil
}

type NoLegacy struct {
}
// Compile time interface enforcer
var _ thrift.Struct = &NoLegacy{}

func NewNoLegacy() *NoLegacy {
    return (&NoLegacy{})
}

// Deprecated: Use NoLegacy.Set* methods instead or set the fields directly.
type NoLegacyBuilder struct {
    obj *NoLegacy
}

func NewNoLegacyBuilder() *NoLegacyBuilder {
    return &NoLegacyBuilder{
        obj: NewNoLegacy(),
    }
}

func (x *NoLegacyBuilder) Emit() *NoLegacy {
    var objCopy NoLegacy = *x.obj
    return &objCopy
}

func (x *NoLegacy) Write(p thrift.Protocol) error {
    if err := p.WriteStructBegin("NoLegacy"); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", x), err)
    }

    if err := p.WriteFieldStop(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", x), err)
    }

    if err := p.WriteStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", x), err)
    }
    return nil
}

func (x *NoLegacy) Read(p thrift.Protocol) error {
    if _, err := p.ReadStructBegin(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read error: ", x), err)
    }

    for {
        _, typ, id, err := p.ReadFieldBegin()
        if err != nil {
            return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", x, id), err)
        }

        if typ == thrift.STOP {
            break;
        }

        switch id {
        default:
            if err := p.Skip(typ); err != nil {
                return err
            }
        }

        if err := p.ReadFieldEnd(); err != nil {
            return err
        }
    }

    if err := p.ReadStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", x), err)
    }

    return nil
}

type NoDeprecated struct {
}
// Compile time interface enforcer
var _ thrift.Struct = &NoDeprecated{}

func NewNoDeprecated() *NoDeprecated {
    return (&NoDeprecated{})
}

// Deprecated: Use NoDeprecated.Set* methods instead or set the fields directly.
type NoDeprecatedBuilder struct {
    obj *NoDeprecated
}

func NewNoDeprecatedBuilder() *NoDeprecatedBuilder {
    return &NoDeprecatedBuilder{
        obj: NewNoDeprecated(),
    }
}

func (x *NoDeprecatedBuilder) Emit() *NoDeprecated {
    var objCopy NoDeprecated = *x.obj
    return &objCopy
}

func (x *NoDeprecated) Write(p thrift.Protocol) error {
    if err := p.WriteStructBegin("NoDeprecated"); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", x), err)
    }

    if err := p.WriteFieldStop(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", x), err)
    }

    if err := p.WriteStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", x), err)
    }
    return nil
}

func (x *NoDeprecated) Read(p thrift.Protocol) error {
    if _, err := p.ReadStructBegin(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read error: ", x), err)
    }

    for {
        _, typ, id, err := p.ReadFieldBegin()
        if err != nil {
            return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", x, id), err)
        }

        if typ == thrift.STOP {
            break;
        }

        switch id {
        default:
            if err := p.Skip(typ); err != nil {
                return err
            }
        }

        if err := p.ReadFieldEnd(); err != nil {
            return err
        }
    }

    if err := p.ReadStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", x), err)
    }

    return nil
}

type TerseWrite struct {
}
// Compile time interface enforcer
var _ thrift.Struct = &TerseWrite{}

func NewTerseWrite() *TerseWrite {
    return (&TerseWrite{})
}

// Deprecated: Use TerseWrite.Set* methods instead or set the fields directly.
type TerseWriteBuilder struct {
    obj *TerseWrite
}

func NewTerseWriteBuilder() *TerseWriteBuilder {
    return &TerseWriteBuilder{
        obj: NewTerseWrite(),
    }
}

func (x *TerseWriteBuilder) Emit() *TerseWrite {
    var objCopy TerseWrite = *x.obj
    return &objCopy
}

func (x *TerseWrite) Write(p thrift.Protocol) error {
    if err := p.WriteStructBegin("TerseWrite"); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", x), err)
    }

    if err := p.WriteFieldStop(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", x), err)
    }

    if err := p.WriteStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", x), err)
    }
    return nil
}

func (x *TerseWrite) Read(p thrift.Protocol) error {
    if _, err := p.ReadStructBegin(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read error: ", x), err)
    }

    for {
        _, typ, id, err := p.ReadFieldBegin()
        if err != nil {
            return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", x, id), err)
        }

        if typ == thrift.STOP {
            break;
        }

        switch id {
        default:
            if err := p.Skip(typ); err != nil {
                return err
            }
        }

        if err := p.ReadFieldEnd(); err != nil {
            return err
        }
    }

    if err := p.ReadStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", x), err)
    }

    return nil
}

type Box struct {
}
// Compile time interface enforcer
var _ thrift.Struct = &Box{}

func NewBox() *Box {
    return (&Box{})
}

// Deprecated: Use Box.Set* methods instead or set the fields directly.
type BoxBuilder struct {
    obj *Box
}

func NewBoxBuilder() *BoxBuilder {
    return &BoxBuilder{
        obj: NewBox(),
    }
}

func (x *BoxBuilder) Emit() *Box {
    var objCopy Box = *x.obj
    return &objCopy
}

func (x *Box) Write(p thrift.Protocol) error {
    if err := p.WriteStructBegin("Box"); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", x), err)
    }

    if err := p.WriteFieldStop(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", x), err)
    }

    if err := p.WriteStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", x), err)
    }
    return nil
}

func (x *Box) Read(p thrift.Protocol) error {
    if _, err := p.ReadStructBegin(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read error: ", x), err)
    }

    for {
        _, typ, id, err := p.ReadFieldBegin()
        if err != nil {
            return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", x, id), err)
        }

        if typ == thrift.STOP {
            break;
        }

        switch id {
        default:
            if err := p.Skip(typ); err != nil {
                return err
            }
        }

        if err := p.ReadFieldEnd(); err != nil {
            return err
        }
    }

    if err := p.ReadStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", x), err)
    }

    return nil
}

type Mixin struct {
}
// Compile time interface enforcer
var _ thrift.Struct = &Mixin{}

func NewMixin() *Mixin {
    return (&Mixin{})
}

// Deprecated: Use Mixin.Set* methods instead or set the fields directly.
type MixinBuilder struct {
    obj *Mixin
}

func NewMixinBuilder() *MixinBuilder {
    return &MixinBuilder{
        obj: NewMixin(),
    }
}

func (x *MixinBuilder) Emit() *Mixin {
    var objCopy Mixin = *x.obj
    return &objCopy
}

func (x *Mixin) Write(p thrift.Protocol) error {
    if err := p.WriteStructBegin("Mixin"); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", x), err)
    }

    if err := p.WriteFieldStop(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", x), err)
    }

    if err := p.WriteStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", x), err)
    }
    return nil
}

func (x *Mixin) Read(p thrift.Protocol) error {
    if _, err := p.ReadStructBegin(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read error: ", x), err)
    }

    for {
        _, typ, id, err := p.ReadFieldBegin()
        if err != nil {
            return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", x, id), err)
        }

        if typ == thrift.STOP {
            break;
        }

        switch id {
        default:
            if err := p.Skip(typ); err != nil {
                return err
            }
        }

        if err := p.ReadFieldEnd(); err != nil {
            return err
        }
    }

    if err := p.ReadStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", x), err)
    }

    return nil
}

type Bit struct {
}
// Compile time interface enforcer
var _ thrift.Struct = &Bit{}

func NewBit() *Bit {
    return (&Bit{})
}

// Deprecated: Use Bit.Set* methods instead or set the fields directly.
type BitBuilder struct {
    obj *Bit
}

func NewBitBuilder() *BitBuilder {
    return &BitBuilder{
        obj: NewBit(),
    }
}

func (x *BitBuilder) Emit() *Bit {
    var objCopy Bit = *x.obj
    return &objCopy
}

func (x *Bit) Write(p thrift.Protocol) error {
    if err := p.WriteStructBegin("Bit"); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", x), err)
    }

    if err := p.WriteFieldStop(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", x), err)
    }

    if err := p.WriteStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", x), err)
    }
    return nil
}

func (x *Bit) Read(p thrift.Protocol) error {
    if _, err := p.ReadStructBegin(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read error: ", x), err)
    }

    for {
        _, typ, id, err := p.ReadFieldBegin()
        if err != nil {
            return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", x, id), err)
        }

        if typ == thrift.STOP {
            break;
        }

        switch id {
        default:
            if err := p.Skip(typ); err != nil {
                return err
            }
        }

        if err := p.ReadFieldEnd(); err != nil {
            return err
        }
    }

    if err := p.ReadStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", x), err)
    }

    return nil
}

type SerializeInFieldIdOrder struct {
}
// Compile time interface enforcer
var _ thrift.Struct = &SerializeInFieldIdOrder{}

func NewSerializeInFieldIdOrder() *SerializeInFieldIdOrder {
    return (&SerializeInFieldIdOrder{})
}

// Deprecated: Use SerializeInFieldIdOrder.Set* methods instead or set the fields directly.
type SerializeInFieldIdOrderBuilder struct {
    obj *SerializeInFieldIdOrder
}

func NewSerializeInFieldIdOrderBuilder() *SerializeInFieldIdOrderBuilder {
    return &SerializeInFieldIdOrderBuilder{
        obj: NewSerializeInFieldIdOrder(),
    }
}

func (x *SerializeInFieldIdOrderBuilder) Emit() *SerializeInFieldIdOrder {
    var objCopy SerializeInFieldIdOrder = *x.obj
    return &objCopy
}

func (x *SerializeInFieldIdOrder) Write(p thrift.Protocol) error {
    if err := p.WriteStructBegin("SerializeInFieldIdOrder"); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", x), err)
    }

    if err := p.WriteFieldStop(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", x), err)
    }

    if err := p.WriteStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", x), err)
    }
    return nil
}

func (x *SerializeInFieldIdOrder) Read(p thrift.Protocol) error {
    if _, err := p.ReadStructBegin(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read error: ", x), err)
    }

    for {
        _, typ, id, err := p.ReadFieldBegin()
        if err != nil {
            return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", x, id), err)
        }

        if typ == thrift.STOP {
            break;
        }

        switch id {
        default:
            if err := p.Skip(typ); err != nil {
                return err
            }
        }

        if err := p.ReadFieldEnd(); err != nil {
            return err
        }
    }

    if err := p.ReadStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", x), err)
    }

    return nil
}

type BitmaskEnum struct {
}
// Compile time interface enforcer
var _ thrift.Struct = &BitmaskEnum{}

func NewBitmaskEnum() *BitmaskEnum {
    return (&BitmaskEnum{})
}

// Deprecated: Use BitmaskEnum.Set* methods instead or set the fields directly.
type BitmaskEnumBuilder struct {
    obj *BitmaskEnum
}

func NewBitmaskEnumBuilder() *BitmaskEnumBuilder {
    return &BitmaskEnumBuilder{
        obj: NewBitmaskEnum(),
    }
}

func (x *BitmaskEnumBuilder) Emit() *BitmaskEnum {
    var objCopy BitmaskEnum = *x.obj
    return &objCopy
}

func (x *BitmaskEnum) Write(p thrift.Protocol) error {
    if err := p.WriteStructBegin("BitmaskEnum"); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", x), err)
    }

    if err := p.WriteFieldStop(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", x), err)
    }

    if err := p.WriteStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", x), err)
    }
    return nil
}

func (x *BitmaskEnum) Read(p thrift.Protocol) error {
    if _, err := p.ReadStructBegin(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read error: ", x), err)
    }

    for {
        _, typ, id, err := p.ReadFieldBegin()
        if err != nil {
            return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", x, id), err)
        }

        if typ == thrift.STOP {
            break;
        }

        switch id {
        default:
            if err := p.Skip(typ); err != nil {
                return err
            }
        }

        if err := p.ReadFieldEnd(); err != nil {
            return err
        }
    }

    if err := p.ReadStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", x), err)
    }

    return nil
}

type GenDefaultEnumValue struct {
    Name string `thrift:"name,1" json:"name" db:"name"`
}
// Compile time interface enforcer
var _ thrift.Struct = &GenDefaultEnumValue{}

func NewGenDefaultEnumValue() *GenDefaultEnumValue {
    return (&GenDefaultEnumValue{}).
        SetName("Unspecified")
}
func (x *GenDefaultEnumValue) GetName() string {
    return x.Name
}

func (x *GenDefaultEnumValue) SetName(value string) *GenDefaultEnumValue {
    x.Name = value
    return x
}


func (x *GenDefaultEnumValue) writeField1(p thrift.Protocol) error {  // Name
    if err := p.WriteFieldBegin("name", thrift.STRING, 1); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field begin error: ", x), err)
    }

    item := x.GetName()
    if err := p.WriteString(item); err != nil {
    return err
}

    if err := p.WriteFieldEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field end error: ", x), err)
    }
    return nil
}

func (x *GenDefaultEnumValue) readField1(p thrift.Protocol) error {  // Name
    result, err := p.ReadString()
if err != nil {
    return err
}

    x.SetName(result)
    return nil
}


// Deprecated: Use GenDefaultEnumValue.Set* methods instead or set the fields directly.
type GenDefaultEnumValueBuilder struct {
    obj *GenDefaultEnumValue
}

func NewGenDefaultEnumValueBuilder() *GenDefaultEnumValueBuilder {
    return &GenDefaultEnumValueBuilder{
        obj: NewGenDefaultEnumValue(),
    }
}

func (x *GenDefaultEnumValueBuilder) Name(value string) *GenDefaultEnumValueBuilder {
    x.obj.Name = value
    return x
}

func (x *GenDefaultEnumValueBuilder) Emit() *GenDefaultEnumValue {
    var objCopy GenDefaultEnumValue = *x.obj
    return &objCopy
}

func (x *GenDefaultEnumValue) Write(p thrift.Protocol) error {
    if err := p.WriteStructBegin("GenDefaultEnumValue"); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", x), err)
    }

    if err := x.writeField1(p); err != nil {
        return err
    }

    if err := p.WriteFieldStop(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", x), err)
    }

    if err := p.WriteStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", x), err)
    }
    return nil
}

func (x *GenDefaultEnumValue) Read(p thrift.Protocol) error {
    if _, err := p.ReadStructBegin(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read error: ", x), err)
    }

    for {
        _, typ, id, err := p.ReadFieldBegin()
        if err != nil {
            return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", x, id), err)
        }

        if typ == thrift.STOP {
            break;
        }

        switch id {
        case 1:  // name
            if err := x.readField1(p); err != nil {
                return err
            }
        default:
            if err := p.Skip(typ); err != nil {
                return err
            }
        }

        if err := p.ReadFieldEnd(); err != nil {
            return err
        }
    }

    if err := p.ReadStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", x), err)
    }

    return nil
}

type GenEnumSet struct {
    Name string `thrift:"name,1" json:"name" db:"name"`
}
// Compile time interface enforcer
var _ thrift.Struct = &GenEnumSet{}

func NewGenEnumSet() *GenEnumSet {
    return (&GenEnumSet{})
}
func (x *GenEnumSet) GetName() string {
    return x.Name
}

func (x *GenEnumSet) SetName(value string) *GenEnumSet {
    x.Name = value
    return x
}


func (x *GenEnumSet) writeField1(p thrift.Protocol) error {  // Name
    if err := p.WriteFieldBegin("name", thrift.STRING, 1); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field begin error: ", x), err)
    }

    item := x.GetName()
    if err := p.WriteString(item); err != nil {
    return err
}

    if err := p.WriteFieldEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field end error: ", x), err)
    }
    return nil
}

func (x *GenEnumSet) readField1(p thrift.Protocol) error {  // Name
    result, err := p.ReadString()
if err != nil {
    return err
}

    x.SetName(result)
    return nil
}


// Deprecated: Use GenEnumSet.Set* methods instead or set the fields directly.
type GenEnumSetBuilder struct {
    obj *GenEnumSet
}

func NewGenEnumSetBuilder() *GenEnumSetBuilder {
    return &GenEnumSetBuilder{
        obj: NewGenEnumSet(),
    }
}

func (x *GenEnumSetBuilder) Name(value string) *GenEnumSetBuilder {
    x.obj.Name = value
    return x
}

func (x *GenEnumSetBuilder) Emit() *GenEnumSet {
    var objCopy GenEnumSet = *x.obj
    return &objCopy
}

func (x *GenEnumSet) Write(p thrift.Protocol) error {
    if err := p.WriteStructBegin("GenEnumSet"); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", x), err)
    }

    if err := x.writeField1(p); err != nil {
        return err
    }

    if err := p.WriteFieldStop(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", x), err)
    }

    if err := p.WriteStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", x), err)
    }
    return nil
}

func (x *GenEnumSet) Read(p thrift.Protocol) error {
    if _, err := p.ReadStructBegin(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read error: ", x), err)
    }

    for {
        _, typ, id, err := p.ReadFieldBegin()
        if err != nil {
            return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", x, id), err)
        }

        if typ == thrift.STOP {
            break;
        }

        switch id {
        case 1:  // name
            if err := x.readField1(p); err != nil {
                return err
            }
        default:
            if err := p.Skip(typ); err != nil {
                return err
            }
        }

        if err := p.ReadFieldEnd(); err != nil {
            return err
        }
    }

    if err := p.ReadStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", x), err)
    }

    return nil
}

type V1 struct {
}
// Compile time interface enforcer
var _ thrift.Struct = &V1{}

func NewV1() *V1 {
    return (&V1{})
}

// Deprecated: Use V1.Set* methods instead or set the fields directly.
type V1Builder struct {
    obj *V1
}

func NewV1Builder() *V1Builder {
    return &V1Builder{
        obj: NewV1(),
    }
}

func (x *V1Builder) Emit() *V1 {
    var objCopy V1 = *x.obj
    return &objCopy
}

func (x *V1) Write(p thrift.Protocol) error {
    if err := p.WriteStructBegin("v1"); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", x), err)
    }

    if err := p.WriteFieldStop(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", x), err)
    }

    if err := p.WriteStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", x), err)
    }
    return nil
}

func (x *V1) Read(p thrift.Protocol) error {
    if _, err := p.ReadStructBegin(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read error: ", x), err)
    }

    for {
        _, typ, id, err := p.ReadFieldBegin()
        if err != nil {
            return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", x, id), err)
        }

        if typ == thrift.STOP {
            break;
        }

        switch id {
        default:
            if err := p.Skip(typ); err != nil {
                return err
            }
        }

        if err := p.ReadFieldEnd(); err != nil {
            return err
        }
    }

    if err := p.ReadStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", x), err)
    }

    return nil
}

type V1beta struct {
}
// Compile time interface enforcer
var _ thrift.Struct = &V1beta{}

func NewV1beta() *V1beta {
    return (&V1beta{})
}

// Deprecated: Use V1beta.Set* methods instead or set the fields directly.
type V1betaBuilder struct {
    obj *V1beta
}

func NewV1betaBuilder() *V1betaBuilder {
    return &V1betaBuilder{
        obj: NewV1beta(),
    }
}

func (x *V1betaBuilder) Emit() *V1beta {
    var objCopy V1beta = *x.obj
    return &objCopy
}

func (x *V1beta) Write(p thrift.Protocol) error {
    if err := p.WriteStructBegin("v1beta"); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", x), err)
    }

    if err := p.WriteFieldStop(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", x), err)
    }

    if err := p.WriteStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", x), err)
    }
    return nil
}

func (x *V1beta) Read(p thrift.Protocol) error {
    if _, err := p.ReadStructBegin(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read error: ", x), err)
    }

    for {
        _, typ, id, err := p.ReadFieldBegin()
        if err != nil {
            return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", x, id), err)
        }

        if typ == thrift.STOP {
            break;
        }

        switch id {
        default:
            if err := p.Skip(typ); err != nil {
                return err
            }
        }

        if err := p.ReadFieldEnd(); err != nil {
            return err
        }
    }

    if err := p.ReadStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", x), err)
    }

    return nil
}

type V1alpha struct {
}
// Compile time interface enforcer
var _ thrift.Struct = &V1alpha{}

func NewV1alpha() *V1alpha {
    return (&V1alpha{})
}

// Deprecated: Use V1alpha.Set* methods instead or set the fields directly.
type V1alphaBuilder struct {
    obj *V1alpha
}

func NewV1alphaBuilder() *V1alphaBuilder {
    return &V1alphaBuilder{
        obj: NewV1alpha(),
    }
}

func (x *V1alphaBuilder) Emit() *V1alpha {
    var objCopy V1alpha = *x.obj
    return &objCopy
}

func (x *V1alpha) Write(p thrift.Protocol) error {
    if err := p.WriteStructBegin("v1alpha"); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", x), err)
    }

    if err := p.WriteFieldStop(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", x), err)
    }

    if err := p.WriteStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", x), err)
    }
    return nil
}

func (x *V1alpha) Read(p thrift.Protocol) error {
    if _, err := p.ReadStructBegin(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read error: ", x), err)
    }

    for {
        _, typ, id, err := p.ReadFieldBegin()
        if err != nil {
            return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", x, id), err)
        }

        if typ == thrift.STOP {
            break;
        }

        switch id {
        default:
            if err := p.Skip(typ); err != nil {
                return err
            }
        }

        if err := p.ReadFieldEnd(); err != nil {
            return err
        }
    }

    if err := p.ReadStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", x), err)
    }

    return nil
}

type V1test struct {
}
// Compile time interface enforcer
var _ thrift.Struct = &V1test{}

func NewV1test() *V1test {
    return (&V1test{})
}

// Deprecated: Use V1test.Set* methods instead or set the fields directly.
type V1testBuilder struct {
    obj *V1test
}

func NewV1testBuilder() *V1testBuilder {
    return &V1testBuilder{
        obj: NewV1test(),
    }
}

func (x *V1testBuilder) Emit() *V1test {
    var objCopy V1test = *x.obj
    return &objCopy
}

func (x *V1test) Write(p thrift.Protocol) error {
    if err := p.WriteStructBegin("v1test"); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", x), err)
    }

    if err := p.WriteFieldStop(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", x), err)
    }

    if err := p.WriteStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", x), err)
    }
    return nil
}

func (x *V1test) Read(p thrift.Protocol) error {
    if _, err := p.ReadStructBegin(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read error: ", x), err)
    }

    for {
        _, typ, id, err := p.ReadFieldBegin()
        if err != nil {
            return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", x, id), err)
        }

        if typ == thrift.STOP {
            break;
        }

        switch id {
        default:
            if err := p.Skip(typ); err != nil {
                return err
            }
        }

        if err := p.ReadFieldEnd(); err != nil {
            return err
        }
    }

    if err := p.ReadStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", x), err)
    }

    return nil
}

type ExceptionMessage struct {
    Field string `thrift:"field,1" json:"field" db:"field"`
}
// Compile time interface enforcer
var _ thrift.Struct = &ExceptionMessage{}

func NewExceptionMessage() *ExceptionMessage {
    return (&ExceptionMessage{})
}
func (x *ExceptionMessage) GetField() string {
    return x.Field
}

func (x *ExceptionMessage) SetField(value string) *ExceptionMessage {
    x.Field = value
    return x
}


func (x *ExceptionMessage) writeField1(p thrift.Protocol) error {  // Field
    if err := p.WriteFieldBegin("field", thrift.STRING, 1); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field begin error: ", x), err)
    }

    item := x.GetField()
    if err := p.WriteString(item); err != nil {
    return err
}

    if err := p.WriteFieldEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field end error: ", x), err)
    }
    return nil
}

func (x *ExceptionMessage) readField1(p thrift.Protocol) error {  // Field
    result, err := p.ReadString()
if err != nil {
    return err
}

    x.SetField(result)
    return nil
}


// Deprecated: Use ExceptionMessage.Set* methods instead or set the fields directly.
type ExceptionMessageBuilder struct {
    obj *ExceptionMessage
}

func NewExceptionMessageBuilder() *ExceptionMessageBuilder {
    return &ExceptionMessageBuilder{
        obj: NewExceptionMessage(),
    }
}

func (x *ExceptionMessageBuilder) Field(value string) *ExceptionMessageBuilder {
    x.obj.Field = value
    return x
}

func (x *ExceptionMessageBuilder) Emit() *ExceptionMessage {
    var objCopy ExceptionMessage = *x.obj
    return &objCopy
}

func (x *ExceptionMessage) Write(p thrift.Protocol) error {
    if err := p.WriteStructBegin("ExceptionMessage"); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", x), err)
    }

    if err := x.writeField1(p); err != nil {
        return err
    }

    if err := p.WriteFieldStop(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", x), err)
    }

    if err := p.WriteStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", x), err)
    }
    return nil
}

func (x *ExceptionMessage) Read(p thrift.Protocol) error {
    if _, err := p.ReadStructBegin(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read error: ", x), err)
    }

    for {
        _, typ, id, err := p.ReadFieldBegin()
        if err != nil {
            return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", x, id), err)
        }

        if typ == thrift.STOP {
            break;
        }

        switch id {
        case 1:  // field
            if err := x.readField1(p); err != nil {
                return err
            }
        default:
            if err := p.Skip(typ); err != nil {
                return err
            }
        }

        if err := p.ReadFieldEnd(); err != nil {
            return err
        }
    }

    if err := p.ReadStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", x), err)
    }

    return nil
}

type GenerateRuntimeSchema struct {
    Name string `thrift:"name,1" json:"name" db:"name"`
}
// Compile time interface enforcer
var _ thrift.Struct = &GenerateRuntimeSchema{}

func NewGenerateRuntimeSchema() *GenerateRuntimeSchema {
    return (&GenerateRuntimeSchema{})
}
func (x *GenerateRuntimeSchema) GetName() string {
    return x.Name
}

func (x *GenerateRuntimeSchema) SetName(value string) *GenerateRuntimeSchema {
    x.Name = value
    return x
}


func (x *GenerateRuntimeSchema) writeField1(p thrift.Protocol) error {  // Name
    if err := p.WriteFieldBegin("name", thrift.STRING, 1); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field begin error: ", x), err)
    }

    item := x.GetName()
    if err := p.WriteString(item); err != nil {
    return err
}

    if err := p.WriteFieldEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field end error: ", x), err)
    }
    return nil
}

func (x *GenerateRuntimeSchema) readField1(p thrift.Protocol) error {  // Name
    result, err := p.ReadString()
if err != nil {
    return err
}

    x.SetName(result)
    return nil
}


// Deprecated: Use GenerateRuntimeSchema.Set* methods instead or set the fields directly.
type GenerateRuntimeSchemaBuilder struct {
    obj *GenerateRuntimeSchema
}

func NewGenerateRuntimeSchemaBuilder() *GenerateRuntimeSchemaBuilder {
    return &GenerateRuntimeSchemaBuilder{
        obj: NewGenerateRuntimeSchema(),
    }
}

func (x *GenerateRuntimeSchemaBuilder) Name(value string) *GenerateRuntimeSchemaBuilder {
    x.obj.Name = value
    return x
}

func (x *GenerateRuntimeSchemaBuilder) Emit() *GenerateRuntimeSchema {
    var objCopy GenerateRuntimeSchema = *x.obj
    return &objCopy
}

func (x *GenerateRuntimeSchema) Write(p thrift.Protocol) error {
    if err := p.WriteStructBegin("GenerateRuntimeSchema"); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", x), err)
    }

    if err := x.writeField1(p); err != nil {
        return err
    }

    if err := p.WriteFieldStop(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", x), err)
    }

    if err := p.WriteStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", x), err)
    }
    return nil
}

func (x *GenerateRuntimeSchema) Read(p thrift.Protocol) error {
    if _, err := p.ReadStructBegin(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read error: ", x), err)
    }

    for {
        _, typ, id, err := p.ReadFieldBegin()
        if err != nil {
            return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", x, id), err)
        }

        if typ == thrift.STOP {
            break;
        }

        switch id {
        case 1:  // name
            if err := x.readField1(p); err != nil {
                return err
            }
        default:
            if err := p.Skip(typ); err != nil {
                return err
            }
        }

        if err := p.ReadFieldEnd(); err != nil {
            return err
        }
    }

    if err := p.ReadStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", x), err)
    }

    return nil
}

type InternBox struct {
}
// Compile time interface enforcer
var _ thrift.Struct = &InternBox{}

func NewInternBox() *InternBox {
    return (&InternBox{})
}

// Deprecated: Use InternBox.Set* methods instead or set the fields directly.
type InternBoxBuilder struct {
    obj *InternBox
}

func NewInternBoxBuilder() *InternBoxBuilder {
    return &InternBoxBuilder{
        obj: NewInternBox(),
    }
}

func (x *InternBoxBuilder) Emit() *InternBox {
    var objCopy InternBox = *x.obj
    return &objCopy
}

func (x *InternBox) Write(p thrift.Protocol) error {
    if err := p.WriteStructBegin("InternBox"); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", x), err)
    }

    if err := p.WriteFieldStop(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", x), err)
    }

    if err := p.WriteStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", x), err)
    }
    return nil
}

func (x *InternBox) Read(p thrift.Protocol) error {
    if _, err := p.ReadStructBegin(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read error: ", x), err)
    }

    for {
        _, typ, id, err := p.ReadFieldBegin()
        if err != nil {
            return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", x, id), err)
        }

        if typ == thrift.STOP {
            break;
        }

        switch id {
        default:
            if err := p.Skip(typ); err != nil {
                return err
            }
        }

        if err := p.ReadFieldEnd(); err != nil {
            return err
        }
    }

    if err := p.ReadStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", x), err)
    }

    return nil
}