baz.go

// Code generated by thriftrw v1.29.2. DO NOT EDIT.
// @generated

package baz

import (
	errors "errors"
	fmt "fmt"
	strings "strings"

	multierr "go.uber.org/multierr"
	stream "go.uber.org/thriftrw/protocol/stream"
	wire "go.uber.org/thriftrw/wire"
	zapcore "go.uber.org/zap/zapcore"
)

type AuthErr struct {
	Message string `json:"message,required"`
}

// ToWire translates a AuthErr struct into a Thrift-level intermediate
// representation. This intermediate representation may be serialized
// into bytes using a ThriftRW protocol implementation.
//
// An error is returned if the struct or any of its fields failed to
// validate.
//
//	x, err := v.ToWire()
//	if err != nil {
//	  return err
//	}
//
//	if err := binaryProtocol.Encode(x, writer); err != nil {
//	  return err
//	}
func (v *AuthErr) ToWire() (wire.Value, error) {
	var (
		fields [1]wire.Field
		i      int = 0
		w      wire.Value
		err    error
	)

	w, err = wire.NewValueString(v.Message), error(nil)
	if err != nil {
		return w, err
	}
	fields[i] = wire.Field{ID: 1, Value: w}
	i++

	return wire.NewValueStruct(wire.Struct{Fields: fields[:i]}), nil
}

// FromWire deserializes a AuthErr struct from its Thrift-level
// representation. The Thrift-level representation may be obtained
// from a ThriftRW protocol implementation.
//
// An error is returned if we were unable to build a AuthErr struct
// from the provided intermediate representation.
//
//	x, err := binaryProtocol.Decode(reader, wire.TStruct)
//	if err != nil {
//	  return nil, err
//	}
//
//	var v AuthErr
//	if err := v.FromWire(x); err != nil {
//	  return nil, err
//	}
//	return &v, nil
func (v *AuthErr) FromWire(w wire.Value) error {
	var err error

	messageIsSet := false

	for _, field := range w.GetStruct().Fields {
		switch field.ID {
		case 1:
			if field.Value.Type() == wire.TBinary {
				v.Message, err = field.Value.GetString(), error(nil)
				if err != nil {
					return err
				}
				messageIsSet = true
			}
		}
	}

	if !messageIsSet {
		return errors.New("field Message of AuthErr is required")
	}

	return nil
}

// Encode serializes a AuthErr struct directly into bytes, without going
// through an intermediary type.
//
// An error is returned if a AuthErr struct could not be encoded.
func (v *AuthErr) Encode(sw stream.Writer) error {
	if err := sw.WriteStructBegin(); err != nil {
		return err
	}

	if err := sw.WriteFieldBegin(stream.FieldHeader{ID: 1, Type: wire.TBinary}); err != nil {
		return err
	}
	if err := sw.WriteString(v.Message); err != nil {
		return err
	}
	if err := sw.WriteFieldEnd(); err != nil {
		return err
	}

	return sw.WriteStructEnd()
}

// Decode deserializes a AuthErr struct directly from its Thrift-level
// representation, without going through an intemediary type.
//
// An error is returned if a AuthErr struct could not be generated from the wire
// representation.
func (v *AuthErr) Decode(sr stream.Reader) error {

	messageIsSet := false

	if err := sr.ReadStructBegin(); err != nil {
		return err
	}

	fh, ok, err := sr.ReadFieldBegin()
	if err != nil {
		return err
	}

	for ok {
		switch {
		case fh.ID == 1 && fh.Type == wire.TBinary:
			v.Message, err = sr.ReadString()
			if err != nil {
				return err
			}
			messageIsSet = true
		default:
			if err := sr.Skip(fh.Type); err != nil {
				return err
			}
		}

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

		if fh, ok, err = sr.ReadFieldBegin(); err != nil {
			return err
		}
	}

	if err := sr.ReadStructEnd(); err != nil {
		return err
	}

	if !messageIsSet {
		return errors.New("field Message of AuthErr is required")
	}

	return nil
}

// String returns a readable string representation of a AuthErr
// struct.
func (v *AuthErr) String() string {
	if v == nil {
		return "<nil>"
	}

	var fields [1]string
	i := 0
	fields[i] = fmt.Sprintf("Message: %v", v.Message)
	i++

	return fmt.Sprintf("AuthErr{%v}", strings.Join(fields[:i], ", "))
}

// ErrorName is the name of this type as defined in the Thrift
// file.
func (*AuthErr) ErrorName() string {
	return "AuthErr"
}

// Equals returns true if all the fields of this AuthErr match the
// provided AuthErr.
//
// This function performs a deep comparison.
func (v *AuthErr) Equals(rhs *AuthErr) bool {
	if v == nil {
		return rhs == nil
	} else if rhs == nil {
		return false
	}
	if !(v.Message == rhs.Message) {
		return false
	}

	return true
}

// MarshalLogObject implements zapcore.ObjectMarshaler, enabling
// fast logging of AuthErr.
func (v *AuthErr) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
	if v == nil {
		return nil
	}
	enc.AddString("message", v.Message)
	return err
}

// GetMessage returns the value of Message if it is set or its
// zero value if it is unset.
func (v *AuthErr) GetMessage() (o string) {
	if v != nil {
		o = v.Message
	}
	return
}

func (v *AuthErr) Error() string {
	return v.String()
}

type BazRequest struct {
	B1 bool   `json:"b1,required"`
	S2 string `json:"s2,required"`
	I3 int32  `json:"i3,required"`
}

// ToWire translates a BazRequest struct into a Thrift-level intermediate
// representation. This intermediate representation may be serialized
// into bytes using a ThriftRW protocol implementation.
//
// An error is returned if the struct or any of its fields failed to
// validate.
//
//	x, err := v.ToWire()
//	if err != nil {
//	  return err
//	}
//
//	if err := binaryProtocol.Encode(x, writer); err != nil {
//	  return err
//	}
func (v *BazRequest) ToWire() (wire.Value, error) {
	var (
		fields [3]wire.Field
		i      int = 0
		w      wire.Value
		err    error
	)

	w, err = wire.NewValueBool(v.B1), error(nil)
	if err != nil {
		return w, err
	}
	fields[i] = wire.Field{ID: 1, Value: w}
	i++

	w, err = wire.NewValueString(v.S2), error(nil)
	if err != nil {
		return w, err
	}
	fields[i] = wire.Field{ID: 2, Value: w}
	i++

	w, err = wire.NewValueI32(v.I3), error(nil)
	if err != nil {
		return w, err
	}
	fields[i] = wire.Field{ID: 3, Value: w}
	i++

	return wire.NewValueStruct(wire.Struct{Fields: fields[:i]}), nil
}

// FromWire deserializes a BazRequest struct from its Thrift-level
// representation. The Thrift-level representation may be obtained
// from a ThriftRW protocol implementation.
//
// An error is returned if we were unable to build a BazRequest struct
// from the provided intermediate representation.
//
//	x, err := binaryProtocol.Decode(reader, wire.TStruct)
//	if err != nil {
//	  return nil, err
//	}
//
//	var v BazRequest
//	if err := v.FromWire(x); err != nil {
//	  return nil, err
//	}
//	return &v, nil
func (v *BazRequest) FromWire(w wire.Value) error {
	var err error

	b1IsSet := false
	s2IsSet := false
	i3IsSet := false

	for _, field := range w.GetStruct().Fields {
		switch field.ID {
		case 1:
			if field.Value.Type() == wire.TBool {
				v.B1, err = field.Value.GetBool(), error(nil)
				if err != nil {
					return err
				}
				b1IsSet = true
			}
		case 2:
			if field.Value.Type() == wire.TBinary {
				v.S2, err = field.Value.GetString(), error(nil)
				if err != nil {
					return err
				}
				s2IsSet = true
			}
		case 3:
			if field.Value.Type() == wire.TI32 {
				v.I3, err = field.Value.GetI32(), error(nil)
				if err != nil {
					return err
				}
				i3IsSet = true
			}
		}
	}

	if !b1IsSet {
		return errors.New("field B1 of BazRequest is required")
	}

	if !s2IsSet {
		return errors.New("field S2 of BazRequest is required")
	}

	if !i3IsSet {
		return errors.New("field I3 of BazRequest is required")
	}

	return nil
}

// Encode serializes a BazRequest struct directly into bytes, without going
// through an intermediary type.
//
// An error is returned if a BazRequest struct could not be encoded.
func (v *BazRequest) Encode(sw stream.Writer) error {
	if err := sw.WriteStructBegin(); err != nil {
		return err
	}

	if err := sw.WriteFieldBegin(stream.FieldHeader{ID: 1, Type: wire.TBool}); err != nil {
		return err
	}
	if err := sw.WriteBool(v.B1); err != nil {
		return err
	}
	if err := sw.WriteFieldEnd(); err != nil {
		return err
	}

	if err := sw.WriteFieldBegin(stream.FieldHeader{ID: 2, Type: wire.TBinary}); err != nil {
		return err
	}
	if err := sw.WriteString(v.S2); err != nil {
		return err
	}
	if err := sw.WriteFieldEnd(); err != nil {
		return err
	}

	if err := sw.WriteFieldBegin(stream.FieldHeader{ID: 3, Type: wire.TI32}); err != nil {
		return err
	}
	if err := sw.WriteInt32(v.I3); err != nil {
		return err
	}
	if err := sw.WriteFieldEnd(); err != nil {
		return err
	}

	return sw.WriteStructEnd()
}

// Decode deserializes a BazRequest struct directly from its Thrift-level
// representation, without going through an intemediary type.
//
// An error is returned if a BazRequest struct could not be generated from the wire
// representation.
func (v *BazRequest) Decode(sr stream.Reader) error {

	b1IsSet := false
	s2IsSet := false
	i3IsSet := false

	if err := sr.ReadStructBegin(); err != nil {
		return err
	}

	fh, ok, err := sr.ReadFieldBegin()
	if err != nil {
		return err
	}

	for ok {
		switch {
		case fh.ID == 1 && fh.Type == wire.TBool:
			v.B1, err = sr.ReadBool()
			if err != nil {
				return err
			}
			b1IsSet = true
		case fh.ID == 2 && fh.Type == wire.TBinary:
			v.S2, err = sr.ReadString()
			if err != nil {
				return err
			}
			s2IsSet = true
		case fh.ID == 3 && fh.Type == wire.TI32:
			v.I3, err = sr.ReadInt32()
			if err != nil {
				return err
			}
			i3IsSet = true
		default:
			if err := sr.Skip(fh.Type); err != nil {
				return err
			}
		}

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

		if fh, ok, err = sr.ReadFieldBegin(); err != nil {
			return err
		}
	}

	if err := sr.ReadStructEnd(); err != nil {
		return err
	}

	if !b1IsSet {
		return errors.New("field B1 of BazRequest is required")
	}

	if !s2IsSet {
		return errors.New("field S2 of BazRequest is required")
	}

	if !i3IsSet {
		return errors.New("field I3 of BazRequest is required")
	}

	return nil
}

// String returns a readable string representation of a BazRequest
// struct.
func (v *BazRequest) String() string {
	if v == nil {
		return "<nil>"
	}

	var fields [3]string
	i := 0
	fields[i] = fmt.Sprintf("B1: %v", v.B1)
	i++
	fields[i] = fmt.Sprintf("S2: %v", v.S2)
	i++
	fields[i] = fmt.Sprintf("I3: %v", v.I3)
	i++

	return fmt.Sprintf("BazRequest{%v}", strings.Join(fields[:i], ", "))
}

// Equals returns true if all the fields of this BazRequest match the
// provided BazRequest.
//
// This function performs a deep comparison.
func (v *BazRequest) Equals(rhs *BazRequest) bool {
	if v == nil {
		return rhs == nil
	} else if rhs == nil {
		return false
	}
	if !(v.B1 == rhs.B1) {
		return false
	}
	if !(v.S2 == rhs.S2) {
		return false
	}
	if !(v.I3 == rhs.I3) {
		return false
	}

	return true
}

// MarshalLogObject implements zapcore.ObjectMarshaler, enabling
// fast logging of BazRequest.
func (v *BazRequest) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
	if v == nil {
		return nil
	}
	enc.AddBool("b1", v.B1)
	enc.AddString("s2", v.S2)
	enc.AddInt32("i3", v.I3)
	return err
}

// GetB1 returns the value of B1 if it is set or its
// zero value if it is unset.
func (v *BazRequest) GetB1() (o bool) {
	if v != nil {
		o = v.B1
	}
	return
}

// GetS2 returns the value of S2 if it is set or its
// zero value if it is unset.
func (v *BazRequest) GetS2() (o string) {
	if v != nil {
		o = v.S2
	}
	return
}

// GetI3 returns the value of I3 if it is set or its
// zero value if it is unset.
func (v *BazRequest) GetI3() (o int32) {
	if v != nil {
		o = v.I3
	}
	return
}

type BazResponse struct {
	Message string `json:"message,required"`
}

// ToWire translates a BazResponse struct into a Thrift-level intermediate
// representation. This intermediate representation may be serialized
// into bytes using a ThriftRW protocol implementation.
//
// An error is returned if the struct or any of its fields failed to
// validate.
//
//	x, err := v.ToWire()
//	if err != nil {
//	  return err
//	}
//
//	if err := binaryProtocol.Encode(x, writer); err != nil {
//	  return err
//	}
func (v *BazResponse) ToWire() (wire.Value, error) {
	var (
		fields [1]wire.Field
		i      int = 0
		w      wire.Value
		err    error
	)

	w, err = wire.NewValueString(v.Message), error(nil)
	if err != nil {
		return w, err
	}
	fields[i] = wire.Field{ID: 1, Value: w}
	i++

	return wire.NewValueStruct(wire.Struct{Fields: fields[:i]}), nil
}

// FromWire deserializes a BazResponse struct from its Thrift-level
// representation. The Thrift-level representation may be obtained
// from a ThriftRW protocol implementation.
//
// An error is returned if we were unable to build a BazResponse struct
// from the provided intermediate representation.
//
//	x, err := binaryProtocol.Decode(reader, wire.TStruct)
//	if err != nil {
//	  return nil, err
//	}
//
//	var v BazResponse
//	if err := v.FromWire(x); err != nil {
//	  return nil, err
//	}
//	return &v, nil
func (v *BazResponse) FromWire(w wire.Value) error {
	var err error

	messageIsSet := false

	for _, field := range w.GetStruct().Fields {
		switch field.ID {
		case 1:
			if field.Value.Type() == wire.TBinary {
				v.Message, err = field.Value.GetString(), error(nil)
				if err != nil {
					return err
				}
				messageIsSet = true
			}
		}
	}

	if !messageIsSet {
		return errors.New("field Message of BazResponse is required")
	}

	return nil
}

// Encode serializes a BazResponse struct directly into bytes, without going
// through an intermediary type.
//
// An error is returned if a BazResponse struct could not be encoded.
func (v *BazResponse) Encode(sw stream.Writer) error {
	if err := sw.WriteStructBegin(); err != nil {
		return err
	}

	if err := sw.WriteFieldBegin(stream.FieldHeader{ID: 1, Type: wire.TBinary}); err != nil {
		return err
	}
	if err := sw.WriteString(v.Message); err != nil {
		return err
	}
	if err := sw.WriteFieldEnd(); err != nil {
		return err
	}

	return sw.WriteStructEnd()
}

// Decode deserializes a BazResponse struct directly from its Thrift-level
// representation, without going through an intemediary type.
//
// An error is returned if a BazResponse struct could not be generated from the wire
// representation.
func (v *BazResponse) Decode(sr stream.Reader) error {

	messageIsSet := false

	if err := sr.ReadStructBegin(); err != nil {
		return err
	}

	fh, ok, err := sr.ReadFieldBegin()
	if err != nil {
		return err
	}

	for ok {
		switch {
		case fh.ID == 1 && fh.Type == wire.TBinary:
			v.Message, err = sr.ReadString()
			if err != nil {
				return err
			}
			messageIsSet = true
		default:
			if err := sr.Skip(fh.Type); err != nil {
				return err
			}
		}

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

		if fh, ok, err = sr.ReadFieldBegin(); err != nil {
			return err
		}
	}

	if err := sr.ReadStructEnd(); err != nil {
		return err
	}

	if !messageIsSet {
		return errors.New("field Message of BazResponse is required")
	}

	return nil
}

// String returns a readable string representation of a BazResponse
// struct.
func (v *BazResponse) String() string {
	if v == nil {
		return "<nil>"
	}

	var fields [1]string
	i := 0
	fields[i] = fmt.Sprintf("Message: %v", v.Message)
	i++

	return fmt.Sprintf("BazResponse{%v}", strings.Join(fields[:i], ", "))
}

// Equals returns true if all the fields of this BazResponse match the
// provided BazResponse.
//
// This function performs a deep comparison.
func (v *BazResponse) Equals(rhs *BazResponse) bool {
	if v == nil {
		return rhs == nil
	} else if rhs == nil {
		return false
	}
	if !(v.Message == rhs.Message) {
		return false
	}

	return true
}

// MarshalLogObject implements zapcore.ObjectMarshaler, enabling
// fast logging of BazResponse.
func (v *BazResponse) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
	if v == nil {
		return nil
	}
	enc.AddString("message", v.Message)
	return err
}

// GetMessage returns the value of Message if it is set or its
// zero value if it is unset.
func (v *BazResponse) GetMessage() (o string) {
	if v != nil {
		o = v.Message
	}
	return
}

type GetProfileRequest struct {
	Target UUID `json:"target,required"`
}

// ToWire translates a GetProfileRequest struct into a Thrift-level intermediate
// representation. This intermediate representation may be serialized
// into bytes using a ThriftRW protocol implementation.
//
// An error is returned if the struct or any of its fields failed to
// validate.
//
//	x, err := v.ToWire()
//	if err != nil {
//	  return err
//	}
//
//	if err := binaryProtocol.Encode(x, writer); err != nil {
//	  return err
//	}
func (v *GetProfileRequest) ToWire() (wire.Value, error) {
	var (
		fields [1]wire.Field
		i      int = 0
		w      wire.Value
		err    error
	)

	w, err = v.Target.ToWire()
	if err != nil {
		return w, err
	}
	fields[i] = wire.Field{ID: 1, Value: w}
	i++

	return wire.NewValueStruct(wire.Struct{Fields: fields[:i]}), nil
}

func _UUID_Read(w wire.Value) (UUID, error) {
	var x UUID
	err := x.FromWire(w)
	return x, err
}

// FromWire deserializes a GetProfileRequest struct from its Thrift-level
// representation. The Thrift-level representation may be obtained
// from a ThriftRW protocol implementation.
//
// An error is returned if we were unable to build a GetProfileRequest struct
// from the provided intermediate representation.
//
//	x, err := binaryProtocol.Decode(reader, wire.TStruct)
//	if err != nil {
//	  return nil, err
//	}
//
//	var v GetProfileRequest
//	if err := v.FromWire(x); err != nil {
//	  return nil, err
//	}
//	return &v, nil
func (v *GetProfileRequest) FromWire(w wire.Value) error {
	var err error

	targetIsSet := false

	for _, field := range w.GetStruct().Fields {
		switch field.ID {
		case 1:
			if field.Value.Type() == wire.TBinary {
				v.Target, err = _UUID_Read(field.Value)
				if err != nil {
					return err
				}
				targetIsSet = true
			}
		}
	}

	if !targetIsSet {
		return errors.New("field Target of GetProfileRequest is required")
	}

	return nil
}

// Encode serializes a GetProfileRequest struct directly into bytes, without going
// through an intermediary type.
//
// An error is returned if a GetProfileRequest struct could not be encoded.
func (v *GetProfileRequest) Encode(sw stream.Writer) error {
	if err := sw.WriteStructBegin(); err != nil {
		return err
	}

	if err := sw.WriteFieldBegin(stream.FieldHeader{ID: 1, Type: wire.TBinary}); err != nil {
		return err
	}
	if err := v.Target.Encode(sw); err != nil {
		return err
	}
	if err := sw.WriteFieldEnd(); err != nil {
		return err
	}

	return sw.WriteStructEnd()
}

func _UUID_Decode(sr stream.Reader) (UUID, error) {
	var x UUID
	err := x.Decode(sr)
	return x, err
}

// Decode deserializes a GetProfileRequest struct directly from its Thrift-level
// representation, without going through an intemediary type.
//
// An error is returned if a GetProfileRequest struct could not be generated from the wire
// representation.
func (v *GetProfileRequest) Decode(sr stream.Reader) error {

	targetIsSet := false

	if err := sr.ReadStructBegin(); err != nil {
		return err
	}

	fh, ok, err := sr.ReadFieldBegin()
	if err != nil {
		return err
	}

	for ok {
		switch {
		case fh.ID == 1 && fh.Type == wire.TBinary:
			v.Target, err = _UUID_Decode(sr)
			if err != nil {
				return err
			}
			targetIsSet = true
		default:
			if err := sr.Skip(fh.Type); err != nil {
				return err
			}
		}

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

		if fh, ok, err = sr.ReadFieldBegin(); err != nil {
			return err
		}
	}

	if err := sr.ReadStructEnd(); err != nil {
		return err
	}

	if !targetIsSet {
		return errors.New("field Target of GetProfileRequest is required")
	}

	return nil
}

// String returns a readable string representation of a GetProfileRequest
// struct.
func (v *GetProfileRequest) String() string {
	if v == nil {
		return "<nil>"
	}

	var fields [1]string
	i := 0
	fields[i] = fmt.Sprintf("Target: %v", v.Target)
	i++

	return fmt.Sprintf("GetProfileRequest{%v}", strings.Join(fields[:i], ", "))
}

// Equals returns true if all the fields of this GetProfileRequest match the
// provided GetProfileRequest.
//
// This function performs a deep comparison.
func (v *GetProfileRequest) Equals(rhs *GetProfileRequest) bool {
	if v == nil {
		return rhs == nil
	} else if rhs == nil {
		return false
	}
	if !(v.Target == rhs.Target) {
		return false
	}

	return true
}

// MarshalLogObject implements zapcore.ObjectMarshaler, enabling
// fast logging of GetProfileRequest.
func (v *GetProfileRequest) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
	if v == nil {
		return nil
	}
	enc.AddString("target", (string)(v.Target))
	return err
}

// GetTarget returns the value of Target if it is set or its
// zero value if it is unset.
func (v *GetProfileRequest) GetTarget() (o UUID) {
	if v != nil {
		o = v.Target
	}
	return
}

type GetProfileResponse struct {
	Payloads []*Profile `json:"payloads,required"`
}

type _List_Profile_ValueList []*Profile

func (v _List_Profile_ValueList) ForEach(f func(wire.Value) error) error {
	for i, x := range v {
		if x == nil {
			return fmt.Errorf("invalid list '[]*Profile', index [%v]: value is nil", i)
		}
		w, err := x.ToWire()
		if err != nil {
			return err
		}
		err = f(w)
		if err != nil {
			return err
		}
	}
	return nil
}

func (v _List_Profile_ValueList) Size() int {
	return len(v)
}

func (_List_Profile_ValueList) ValueType() wire.Type {
	return wire.TStruct
}

func (_List_Profile_ValueList) Close() {}

// ToWire translates a GetProfileResponse struct into a Thrift-level intermediate
// representation. This intermediate representation may be serialized
// into bytes using a ThriftRW protocol implementation.
//
// An error is returned if the struct or any of its fields failed to
// validate.
//
//	x, err := v.ToWire()
//	if err != nil {
//	  return err
//	}
//
//	if err := binaryProtocol.Encode(x, writer); err != nil {
//	  return err
//	}
func (v *GetProfileResponse) ToWire() (wire.Value, error) {
	var (
		fields [1]wire.Field
		i      int = 0
		w      wire.Value
		err    error
	)

	w, err = wire.NewValueList(_List_Profile_ValueList(v.Payloads)), error(nil)
	if err != nil {
		return w, err
	}
	fields[i] = wire.Field{ID: 1, Value: w}
	i++

	return wire.NewValueStruct(wire.Struct{Fields: fields[:i]}), nil
}

func _Profile_Read(w wire.Value) (*Profile, error) {
	var v Profile
	err := v.FromWire(w)
	return &v, err
}

func _List_Profile_Read(l wire.ValueList) ([]*Profile, error) {
	if l.ValueType() != wire.TStruct {
		return nil, nil
	}

	o := make([]*Profile, 0, l.Size())
	err := l.ForEach(func(x wire.Value) error {
		i, err := _Profile_Read(x)
		if err != nil {
			return err
		}
		o = append(o, i)
		return nil
	})
	l.Close()
	return o, err
}

// FromWire deserializes a GetProfileResponse struct from its Thrift-level
// representation. The Thrift-level representation may be obtained
// from a ThriftRW protocol implementation.
//
// An error is returned if we were unable to build a GetProfileResponse struct
// from the provided intermediate representation.
//
//	x, err := binaryProtocol.Decode(reader, wire.TStruct)
//	if err != nil {
//	  return nil, err
//	}
//
//	var v GetProfileResponse
//	if err := v.FromWire(x); err != nil {
//	  return nil, err
//	}
//	return &v, nil
func (v *GetProfileResponse) FromWire(w wire.Value) error {
	var err error

	payloadsIsSet := false

	for _, field := range w.GetStruct().Fields {
		switch field.ID {
		case 1:
			if field.Value.Type() == wire.TList {
				v.Payloads, err = _List_Profile_Read(field.Value.GetList())
				if err != nil {
					return err
				}
				payloadsIsSet = true
			}
		}
	}

	if !payloadsIsSet {
		return errors.New("field Payloads of GetProfileResponse is required")
	}

	return nil
}

func _List_Profile_Encode(val []*Profile, sw stream.Writer) error {

	lh := stream.ListHeader{
		Type:   wire.TStruct,
		Length: len(val),
	}
	if err := sw.WriteListBegin(lh); err != nil {
		return err
	}

	for i, v := range val {
		if v == nil {
			return fmt.Errorf("invalid list '[]*Profile', index [%v]: value is nil", i)
		}
		if err := v.Encode(sw); err != nil {
			return err
		}
	}
	return sw.WriteListEnd()
}

// Encode serializes a GetProfileResponse struct directly into bytes, without going
// through an intermediary type.
//
// An error is returned if a GetProfileResponse struct could not be encoded.
func (v *GetProfileResponse) Encode(sw stream.Writer) error {
	if err := sw.WriteStructBegin(); err != nil {
		return err
	}

	if err := sw.WriteFieldBegin(stream.FieldHeader{ID: 1, Type: wire.TList}); err != nil {
		return err
	}
	if err := _List_Profile_Encode(v.Payloads, sw); err != nil {
		return err
	}
	if err := sw.WriteFieldEnd(); err != nil {
		return err
	}

	return sw.WriteStructEnd()
}

func _Profile_Decode(sr stream.Reader) (*Profile, error) {
	var v Profile
	err := v.Decode(sr)
	return &v, err
}

func _List_Profile_Decode(sr stream.Reader) ([]*Profile, error) {
	lh, err := sr.ReadListBegin()
	if err != nil {
		return nil, err
	}

	if lh.Type != wire.TStruct {
		for i := 0; i < lh.Length; i++ {
			if err := sr.Skip(lh.Type); err != nil {
				return nil, err
			}
		}
		return nil, sr.ReadListEnd()
	}

	o := make([]*Profile, 0, lh.Length)
	for i := 0; i < lh.Length; i++ {
		v, err := _Profile_Decode(sr)
		if err != nil {
			return nil, err
		}
		o = append(o, v)
	}

	if err = sr.ReadListEnd(); err != nil {
		return nil, err
	}
	return o, err
}

// Decode deserializes a GetProfileResponse struct directly from its Thrift-level
// representation, without going through an intemediary type.
//
// An error is returned if a GetProfileResponse struct could not be generated from the wire
// representation.
func (v *GetProfileResponse) Decode(sr stream.Reader) error {

	payloadsIsSet := false

	if err := sr.ReadStructBegin(); err != nil {
		return err
	}

	fh, ok, err := sr.ReadFieldBegin()
	if err != nil {
		return err
	}

	for ok {
		switch {
		case fh.ID == 1 && fh.Type == wire.TList:
			v.Payloads, err = _List_Profile_Decode(sr)
			if err != nil {
				return err
			}
			payloadsIsSet = true
		default:
			if err := sr.Skip(fh.Type); err != nil {
				return err
			}
		}

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

		if fh, ok, err = sr.ReadFieldBegin(); err != nil {
			return err
		}
	}

	if err := sr.ReadStructEnd(); err != nil {
		return err
	}

	if !payloadsIsSet {
		return errors.New("field Payloads of GetProfileResponse is required")
	}

	return nil
}

// String returns a readable string representation of a GetProfileResponse
// struct.
func (v *GetProfileResponse) String() string {
	if v == nil {
		return "<nil>"
	}

	var fields [1]string
	i := 0
	fields[i] = fmt.Sprintf("Payloads: %v", v.Payloads)
	i++

	return fmt.Sprintf("GetProfileResponse{%v}", strings.Join(fields[:i], ", "))
}

func _List_Profile_Equals(lhs, rhs []*Profile) bool {
	if len(lhs) != len(rhs) {
		return false
	}

	for i, lv := range lhs {
		rv := rhs[i]
		if !lv.Equals(rv) {
			return false
		}
	}

	return true
}

// Equals returns true if all the fields of this GetProfileResponse match the
// provided GetProfileResponse.
//
// This function performs a deep comparison.
func (v *GetProfileResponse) Equals(rhs *GetProfileResponse) bool {
	if v == nil {
		return rhs == nil
	} else if rhs == nil {
		return false
	}
	if !_List_Profile_Equals(v.Payloads, rhs.Payloads) {
		return false
	}

	return true
}

type _List_Profile_Zapper []*Profile

// MarshalLogArray implements zapcore.ArrayMarshaler, enabling
// fast logging of _List_Profile_Zapper.
func (l _List_Profile_Zapper) MarshalLogArray(enc zapcore.ArrayEncoder) (err error) {
	for _, v := range l {
		err = multierr.Append(err, enc.AppendObject(v))
	}
	return err
}

// MarshalLogObject implements zapcore.ObjectMarshaler, enabling
// fast logging of GetProfileResponse.
func (v *GetProfileResponse) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
	if v == nil {
		return nil
	}
	err = multierr.Append(err, enc.AddArray("payloads", (_List_Profile_Zapper)(v.Payloads)))
	return err
}

// GetPayloads returns the value of Payloads if it is set or its
// zero value if it is unset.
func (v *GetProfileResponse) GetPayloads() (o []*Profile) {
	if v != nil {
		o = v.Payloads
	}
	return
}

// IsSetPayloads returns true if Payloads is not nil.
func (v *GetProfileResponse) IsSetPayloads() bool {
	return v != nil && v.Payloads != nil
}

type HeaderSchema struct {
}

// ToWire translates a HeaderSchema struct into a Thrift-level intermediate
// representation. This intermediate representation may be serialized
// into bytes using a ThriftRW protocol implementation.
//
// An error is returned if the struct or any of its fields failed to
// validate.
//
//	x, err := v.ToWire()
//	if err != nil {
//	  return err
//	}
//
//	if err := binaryProtocol.Encode(x, writer); err != nil {
//	  return err
//	}
func (v *HeaderSchema) ToWire() (wire.Value, error) {
	var (
		fields [0]wire.Field
		i      int = 0
	)

	return wire.NewValueStruct(wire.Struct{Fields: fields[:i]}), nil
}

// FromWire deserializes a HeaderSchema struct from its Thrift-level
// representation. The Thrift-level representation may be obtained
// from a ThriftRW protocol implementation.
//
// An error is returned if we were unable to build a HeaderSchema struct
// from the provided intermediate representation.
//
//	x, err := binaryProtocol.Decode(reader, wire.TStruct)
//	if err != nil {
//	  return nil, err
//	}
//
//	var v HeaderSchema
//	if err := v.FromWire(x); err != nil {
//	  return nil, err
//	}
//	return &v, nil
func (v *HeaderSchema) FromWire(w wire.Value) error {

	for _, field := range w.GetStruct().Fields {
		switch field.ID {
		}
	}

	return nil
}

// Encode serializes a HeaderSchema struct directly into bytes, without going
// through an intermediary type.
//
// An error is returned if a HeaderSchema struct could not be encoded.
func (v *HeaderSchema) Encode(sw stream.Writer) error {
	if err := sw.WriteStructBegin(); err != nil {
		return err
	}

	return sw.WriteStructEnd()
}

// Decode deserializes a HeaderSchema struct directly from its Thrift-level
// representation, without going through an intemediary type.
//
// An error is returned if a HeaderSchema struct could not be generated from the wire
// representation.
func (v *HeaderSchema) Decode(sr stream.Reader) error {

	if err := sr.ReadStructBegin(); err != nil {
		return err
	}

	fh, ok, err := sr.ReadFieldBegin()
	if err != nil {
		return err
	}

	for ok {
		switch {
		default:
			if err := sr.Skip(fh.Type); err != nil {
				return err
			}
		}

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

		if fh, ok, err = sr.ReadFieldBegin(); err != nil {
			return err
		}
	}

	if err := sr.ReadStructEnd(); err != nil {
		return err
	}

	return nil
}

// String returns a readable string representation of a HeaderSchema
// struct.
func (v *HeaderSchema) String() string {
	if v == nil {
		return "<nil>"
	}

	var fields [0]string
	i := 0

	return fmt.Sprintf("HeaderSchema{%v}", strings.Join(fields[:i], ", "))
}

// Equals returns true if all the fields of this HeaderSchema match the
// provided HeaderSchema.
//
// This function performs a deep comparison.
func (v *HeaderSchema) Equals(rhs *HeaderSchema) bool {
	if v == nil {
		return rhs == nil
	} else if rhs == nil {
		return false
	}

	return true
}

// MarshalLogObject implements zapcore.ObjectMarshaler, enabling
// fast logging of HeaderSchema.
func (v *HeaderSchema) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
	if v == nil {
		return nil
	}
	return err
}

type NestedStruct struct {
	Msg   string `json:"msg,required"`
	Check *int32 `json:"check,omitempty"`
}

// ToWire translates a NestedStruct struct into a Thrift-level intermediate
// representation. This intermediate representation may be serialized
// into bytes using a ThriftRW protocol implementation.
//
// An error is returned if the struct or any of its fields failed to
// validate.
//
//	x, err := v.ToWire()
//	if err != nil {
//	  return err
//	}
//
//	if err := binaryProtocol.Encode(x, writer); err != nil {
//	  return err
//	}
func (v *NestedStruct) ToWire() (wire.Value, error) {
	var (
		fields [2]wire.Field
		i      int = 0
		w      wire.Value
		err    error
	)

	w, err = wire.NewValueString(v.Msg), error(nil)
	if err != nil {
		return w, err
	}
	fields[i] = wire.Field{ID: 1, Value: w}
	i++
	if v.Check != nil {
		w, err = wire.NewValueI32(*(v.Check)), error(nil)
		if err != nil {
			return w, err
		}
		fields[i] = wire.Field{ID: 2, Value: w}
		i++
	}

	return wire.NewValueStruct(wire.Struct{Fields: fields[:i]}), nil
}

// FromWire deserializes a NestedStruct struct from its Thrift-level
// representation. The Thrift-level representation may be obtained
// from a ThriftRW protocol implementation.
//
// An error is returned if we were unable to build a NestedStruct struct
// from the provided intermediate representation.
//
//	x, err := binaryProtocol.Decode(reader, wire.TStruct)
//	if err != nil {
//	  return nil, err
//	}
//
//	var v NestedStruct
//	if err := v.FromWire(x); err != nil {
//	  return nil, err
//	}
//	return &v, nil
func (v *NestedStruct) FromWire(w wire.Value) error {
	var err error

	msgIsSet := false

	for _, field := range w.GetStruct().Fields {
		switch field.ID {
		case 1:
			if field.Value.Type() == wire.TBinary {
				v.Msg, err = field.Value.GetString(), error(nil)
				if err != nil {
					return err
				}
				msgIsSet = true
			}
		case 2:
			if field.Value.Type() == wire.TI32 {
				var x int32
				x, err = field.Value.GetI32(), error(nil)
				v.Check = &x
				if err != nil {
					return err
				}

			}
		}
	}

	if !msgIsSet {
		return errors.New("field Msg of NestedStruct is required")
	}

	return nil
}

// Encode serializes a NestedStruct struct directly into bytes, without going
// through an intermediary type.
//
// An error is returned if a NestedStruct struct could not be encoded.
func (v *NestedStruct) Encode(sw stream.Writer) error {
	if err := sw.WriteStructBegin(); err != nil {
		return err
	}

	if err := sw.WriteFieldBegin(stream.FieldHeader{ID: 1, Type: wire.TBinary}); err != nil {
		return err
	}
	if err := sw.WriteString(v.Msg); err != nil {
		return err
	}
	if err := sw.WriteFieldEnd(); err != nil {
		return err
	}

	if v.Check != nil {
		if err := sw.WriteFieldBegin(stream.FieldHeader{ID: 2, Type: wire.TI32}); err != nil {
			return err
		}
		if err := sw.WriteInt32(*(v.Check)); err != nil {
			return err
		}
		if err := sw.WriteFieldEnd(); err != nil {
			return err
		}
	}

	return sw.WriteStructEnd()
}

// Decode deserializes a NestedStruct struct directly from its Thrift-level
// representation, without going through an intemediary type.
//
// An error is returned if a NestedStruct struct could not be generated from the wire
// representation.
func (v *NestedStruct) Decode(sr stream.Reader) error {

	msgIsSet := false

	if err := sr.ReadStructBegin(); err != nil {
		return err
	}

	fh, ok, err := sr.ReadFieldBegin()
	if err != nil {
		return err
	}

	for ok {
		switch {
		case fh.ID == 1 && fh.Type == wire.TBinary:
			v.Msg, err = sr.ReadString()
			if err != nil {
				return err
			}
			msgIsSet = true
		case fh.ID == 2 && fh.Type == wire.TI32:
			var x int32
			x, err = sr.ReadInt32()
			v.Check = &x
			if err != nil {
				return err
			}

		default:
			if err := sr.Skip(fh.Type); err != nil {
				return err
			}
		}

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

		if fh, ok, err = sr.ReadFieldBegin(); err != nil {
			return err
		}
	}

	if err := sr.ReadStructEnd(); err != nil {
		return err
	}

	if !msgIsSet {
		return errors.New("field Msg of NestedStruct is required")
	}

	return nil
}

// String returns a readable string representation of a NestedStruct
// struct.
func (v *NestedStruct) String() string {
	if v == nil {
		return "<nil>"
	}

	var fields [2]string
	i := 0
	fields[i] = fmt.Sprintf("Msg: %v", v.Msg)
	i++
	if v.Check != nil {
		fields[i] = fmt.Sprintf("Check: %v", *(v.Check))
		i++
	}

	return fmt.Sprintf("NestedStruct{%v}", strings.Join(fields[:i], ", "))
}

func _I32_EqualsPtr(lhs, rhs *int32) bool {
	if lhs != nil && rhs != nil {

		x := *lhs
		y := *rhs
		return (x == y)
	}
	return lhs == nil && rhs == nil
}

// Equals returns true if all the fields of this NestedStruct match the
// provided NestedStruct.
//
// This function performs a deep comparison.
func (v *NestedStruct) Equals(rhs *NestedStruct) bool {
	if v == nil {
		return rhs == nil
	} else if rhs == nil {
		return false
	}
	if !(v.Msg == rhs.Msg) {
		return false
	}
	if !_I32_EqualsPtr(v.Check, rhs.Check) {
		return false
	}

	return true
}

// MarshalLogObject implements zapcore.ObjectMarshaler, enabling
// fast logging of NestedStruct.
func (v *NestedStruct) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
	if v == nil {
		return nil
	}
	enc.AddString("msg", v.Msg)
	if v.Check != nil {
		enc.AddInt32("check", *v.Check)
	}
	return err
}

// GetMsg returns the value of Msg if it is set or its
// zero value if it is unset.
func (v *NestedStruct) GetMsg() (o string) {
	if v != nil {
		o = v.Msg
	}
	return
}

// GetCheck returns the value of Check if it is set or its
// zero value if it is unset.
func (v *NestedStruct) GetCheck() (o int32) {
	if v != nil && v.Check != nil {
		return *v.Check
	}

	return
}

// IsSetCheck returns true if Check is not nil.
func (v *NestedStruct) IsSetCheck() bool {
	return v != nil && v.Check != nil
}

type OtherAuthErr struct {
	Message string `json:"message,required"`
}

// ToWire translates a OtherAuthErr struct into a Thrift-level intermediate
// representation. This intermediate representation may be serialized
// into bytes using a ThriftRW protocol implementation.
//
// An error is returned if the struct or any of its fields failed to
// validate.
//
//	x, err := v.ToWire()
//	if err != nil {
//	  return err
//	}
//
//	if err := binaryProtocol.Encode(x, writer); err != nil {
//	  return err
//	}
func (v *OtherAuthErr) ToWire() (wire.Value, error) {
	var (
		fields [1]wire.Field
		i      int = 0
		w      wire.Value
		err    error
	)

	w, err = wire.NewValueString(v.Message), error(nil)
	if err != nil {
		return w, err
	}
	fields[i] = wire.Field{ID: 1, Value: w}
	i++

	return wire.NewValueStruct(wire.Struct{Fields: fields[:i]}), nil
}

// FromWire deserializes a OtherAuthErr struct from its Thrift-level
// representation. The Thrift-level representation may be obtained
// from a ThriftRW protocol implementation.
//
// An error is returned if we were unable to build a OtherAuthErr struct
// from the provided intermediate representation.
//
//	x, err := binaryProtocol.Decode(reader, wire.TStruct)
//	if err != nil {
//	  return nil, err
//	}
//
//	var v OtherAuthErr
//	if err := v.FromWire(x); err != nil {
//	  return nil, err
//	}
//	return &v, nil
func (v *OtherAuthErr) FromWire(w wire.Value) error {
	var err error

	messageIsSet := false

	for _, field := range w.GetStruct().Fields {
		switch field.ID {
		case 1:
			if field.Value.Type() == wire.TBinary {
				v.Message, err = field.Value.GetString(), error(nil)
				if err != nil {
					return err
				}
				messageIsSet = true
			}
		}
	}

	if !messageIsSet {
		return errors.New("field Message of OtherAuthErr is required")
	}

	return nil
}

// Encode serializes a OtherAuthErr struct directly into bytes, without going
// through an intermediary type.
//
// An error is returned if a OtherAuthErr struct could not be encoded.
func (v *OtherAuthErr) Encode(sw stream.Writer) error {
	if err := sw.WriteStructBegin(); err != nil {
		return err
	}

	if err := sw.WriteFieldBegin(stream.FieldHeader{ID: 1, Type: wire.TBinary}); err != nil {
		return err
	}
	if err := sw.WriteString(v.Message); err != nil {
		return err
	}
	if err := sw.WriteFieldEnd(); err != nil {
		return err
	}

	return sw.WriteStructEnd()
}

// Decode deserializes a OtherAuthErr struct directly from its Thrift-level
// representation, without going through an intemediary type.
//
// An error is returned if a OtherAuthErr struct could not be generated from the wire
// representation.
func (v *OtherAuthErr) Decode(sr stream.Reader) error {

	messageIsSet := false

	if err := sr.ReadStructBegin(); err != nil {
		return err
	}

	fh, ok, err := sr.ReadFieldBegin()
	if err != nil {
		return err
	}

	for ok {
		switch {
		case fh.ID == 1 && fh.Type == wire.TBinary:
			v.Message, err = sr.ReadString()
			if err != nil {
				return err
			}
			messageIsSet = true
		default:
			if err := sr.Skip(fh.Type); err != nil {
				return err
			}
		}

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

		if fh, ok, err = sr.ReadFieldBegin(); err != nil {
			return err
		}
	}

	if err := sr.ReadStructEnd(); err != nil {
		return err
	}

	if !messageIsSet {
		return errors.New("field Message of OtherAuthErr is required")
	}

	return nil
}

// String returns a readable string representation of a OtherAuthErr
// struct.
func (v *OtherAuthErr) String() string {
	if v == nil {
		return "<nil>"
	}

	var fields [1]string
	i := 0
	fields[i] = fmt.Sprintf("Message: %v", v.Message)
	i++

	return fmt.Sprintf("OtherAuthErr{%v}", strings.Join(fields[:i], ", "))
}

// ErrorName is the name of this type as defined in the Thrift
// file.
func (*OtherAuthErr) ErrorName() string {
	return "OtherAuthErr"
}

// Equals returns true if all the fields of this OtherAuthErr match the
// provided OtherAuthErr.
//
// This function performs a deep comparison.
func (v *OtherAuthErr) Equals(rhs *OtherAuthErr) bool {
	if v == nil {
		return rhs == nil
	} else if rhs == nil {
		return false
	}
	if !(v.Message == rhs.Message) {
		return false
	}

	return true
}

// MarshalLogObject implements zapcore.ObjectMarshaler, enabling
// fast logging of OtherAuthErr.
func (v *OtherAuthErr) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
	if v == nil {
		return nil
	}
	enc.AddString("message", v.Message)
	return err
}

// GetMessage returns the value of Message if it is set or its
// zero value if it is unset.
func (v *OtherAuthErr) GetMessage() (o string) {
	if v != nil {
		o = v.Message
	}
	return
}

func (v *OtherAuthErr) Error() string {
	return v.String()
}

type Profile struct {
	Recur1 *Recur1 `json:"recur1,required"`
}

// ToWire translates a Profile struct into a Thrift-level intermediate
// representation. This intermediate representation may be serialized
// into bytes using a ThriftRW protocol implementation.
//
// An error is returned if the struct or any of its fields failed to
// validate.
//
//	x, err := v.ToWire()
//	if err != nil {
//	  return err
//	}
//
//	if err := binaryProtocol.Encode(x, writer); err != nil {
//	  return err
//	}
func (v *Profile) ToWire() (wire.Value, error) {
	var (
		fields [1]wire.Field
		i      int = 0
		w      wire.Value
		err    error
	)

	if v.Recur1 == nil {
		return w, errors.New("field Recur1 of Profile is required")
	}
	w, err = v.Recur1.ToWire()
	if err != nil {
		return w, err
	}
	fields[i] = wire.Field{ID: 1, Value: w}
	i++

	return wire.NewValueStruct(wire.Struct{Fields: fields[:i]}), nil
}

func _Recur1_Read(w wire.Value) (*Recur1, error) {
	var v Recur1
	err := v.FromWire(w)
	return &v, err
}

// FromWire deserializes a Profile struct from its Thrift-level
// representation. The Thrift-level representation may be obtained
// from a ThriftRW protocol implementation.
//
// An error is returned if we were unable to build a Profile struct
// from the provided intermediate representation.
//
//	x, err := binaryProtocol.Decode(reader, wire.TStruct)
//	if err != nil {
//	  return nil, err
//	}
//
//	var v Profile
//	if err := v.FromWire(x); err != nil {
//	  return nil, err
//	}
//	return &v, nil
func (v *Profile) FromWire(w wire.Value) error {
	var err error

	recur1IsSet := false

	for _, field := range w.GetStruct().Fields {
		switch field.ID {
		case 1:
			if field.Value.Type() == wire.TStruct {
				v.Recur1, err = _Recur1_Read(field.Value)
				if err != nil {
					return err
				}
				recur1IsSet = true
			}
		}
	}

	if !recur1IsSet {
		return errors.New("field Recur1 of Profile is required")
	}

	return nil
}

// Encode serializes a Profile struct directly into bytes, without going
// through an intermediary type.
//
// An error is returned if a Profile struct could not be encoded.
func (v *Profile) Encode(sw stream.Writer) error {
	if err := sw.WriteStructBegin(); err != nil {
		return err
	}

	if v.Recur1 == nil {
		return errors.New("field Recur1 of Profile is required")
	}
	if err := sw.WriteFieldBegin(stream.FieldHeader{ID: 1, Type: wire.TStruct}); err != nil {
		return err
	}
	if err := v.Recur1.Encode(sw); err != nil {
		return err
	}
	if err := sw.WriteFieldEnd(); err != nil {
		return err
	}

	return sw.WriteStructEnd()
}

func _Recur1_Decode(sr stream.Reader) (*Recur1, error) {
	var v Recur1
	err := v.Decode(sr)
	return &v, err
}

// Decode deserializes a Profile struct directly from its Thrift-level
// representation, without going through an intemediary type.
//
// An error is returned if a Profile struct could not be generated from the wire
// representation.
func (v *Profile) Decode(sr stream.Reader) error {

	recur1IsSet := false

	if err := sr.ReadStructBegin(); err != nil {
		return err
	}

	fh, ok, err := sr.ReadFieldBegin()
	if err != nil {
		return err
	}

	for ok {
		switch {
		case fh.ID == 1 && fh.Type == wire.TStruct:
			v.Recur1, err = _Recur1_Decode(sr)
			if err != nil {
				return err
			}
			recur1IsSet = true
		default:
			if err := sr.Skip(fh.Type); err != nil {
				return err
			}
		}

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

		if fh, ok, err = sr.ReadFieldBegin(); err != nil {
			return err
		}
	}

	if err := sr.ReadStructEnd(); err != nil {
		return err
	}

	if !recur1IsSet {
		return errors.New("field Recur1 of Profile is required")
	}

	return nil
}

// String returns a readable string representation of a Profile
// struct.
func (v *Profile) String() string {
	if v == nil {
		return "<nil>"
	}

	var fields [1]string
	i := 0
	fields[i] = fmt.Sprintf("Recur1: %v", v.Recur1)
	i++

	return fmt.Sprintf("Profile{%v}", strings.Join(fields[:i], ", "))
}

// Equals returns true if all the fields of this Profile match the
// provided Profile.
//
// This function performs a deep comparison.
func (v *Profile) Equals(rhs *Profile) bool {
	if v == nil {
		return rhs == nil
	} else if rhs == nil {
		return false
	}
	if !v.Recur1.Equals(rhs.Recur1) {
		return false
	}

	return true
}

// MarshalLogObject implements zapcore.ObjectMarshaler, enabling
// fast logging of Profile.
func (v *Profile) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
	if v == nil {
		return nil
	}
	err = multierr.Append(err, enc.AddObject("recur1", v.Recur1))
	return err
}

// GetRecur1 returns the value of Recur1 if it is set or its
// zero value if it is unset.
func (v *Profile) GetRecur1() (o *Recur1) {
	if v != nil {
		o = v.Recur1
	}
	return
}

// IsSetRecur1 returns true if Recur1 is not nil.
func (v *Profile) IsSetRecur1() bool {
	return v != nil && v.Recur1 != nil
}

type Recur1 struct {
	Field1 map[UUID]*Recur2 `json:"field1,required"`
}

type _Map_UUID_Recur2_MapItemList map[UUID]*Recur2

func (m _Map_UUID_Recur2_MapItemList) ForEach(f func(wire.MapItem) error) error {
	for k, v := range m {
		if v == nil {
			return fmt.Errorf("invalid map 'map[UUID]*Recur2', key [%v]: value is nil", k)
		}
		kw, err := k.ToWire()
		if err != nil {
			return err
		}

		vw, err := v.ToWire()
		if err != nil {
			return err
		}
		err = f(wire.MapItem{Key: kw, Value: vw})
		if err != nil {
			return err
		}
	}
	return nil
}

func (m _Map_UUID_Recur2_MapItemList) Size() int {
	return len(m)
}

func (_Map_UUID_Recur2_MapItemList) KeyType() wire.Type {
	return wire.TBinary
}

func (_Map_UUID_Recur2_MapItemList) ValueType() wire.Type {
	return wire.TStruct
}

func (_Map_UUID_Recur2_MapItemList) Close() {}

// ToWire translates a Recur1 struct into a Thrift-level intermediate
// representation. This intermediate representation may be serialized
// into bytes using a ThriftRW protocol implementation.
//
// An error is returned if the struct or any of its fields failed to
// validate.
//
//	x, err := v.ToWire()
//	if err != nil {
//	  return err
//	}
//
//	if err := binaryProtocol.Encode(x, writer); err != nil {
//	  return err
//	}
func (v *Recur1) ToWire() (wire.Value, error) {
	var (
		fields [1]wire.Field
		i      int = 0
		w      wire.Value
		err    error
	)

	if v.Field1 == nil {
		return w, errors.New("field Field1 of Recur1 is required")
	}
	w, err = wire.NewValueMap(_Map_UUID_Recur2_MapItemList(v.Field1)), error(nil)
	if err != nil {
		return w, err
	}
	fields[i] = wire.Field{ID: 1, Value: w}
	i++

	return wire.NewValueStruct(wire.Struct{Fields: fields[:i]}), nil
}

func _Recur2_Read(w wire.Value) (*Recur2, error) {
	var v Recur2
	err := v.FromWire(w)
	return &v, err
}

func _Map_UUID_Recur2_Read(m wire.MapItemList) (map[UUID]*Recur2, error) {
	if m.KeyType() != wire.TBinary {
		return nil, nil
	}

	if m.ValueType() != wire.TStruct {
		return nil, nil
	}

	o := make(map[UUID]*Recur2, m.Size())
	err := m.ForEach(func(x wire.MapItem) error {
		k, err := _UUID_Read(x.Key)
		if err != nil {
			return err
		}

		v, err := _Recur2_Read(x.Value)
		if err != nil {
			return err
		}

		o[k] = v
		return nil
	})
	m.Close()
	return o, err
}

// FromWire deserializes a Recur1 struct from its Thrift-level
// representation. The Thrift-level representation may be obtained
// from a ThriftRW protocol implementation.
//
// An error is returned if we were unable to build a Recur1 struct
// from the provided intermediate representation.
//
//	x, err := binaryProtocol.Decode(reader, wire.TStruct)
//	if err != nil {
//	  return nil, err
//	}
//
//	var v Recur1
//	if err := v.FromWire(x); err != nil {
//	  return nil, err
//	}
//	return &v, nil
func (v *Recur1) FromWire(w wire.Value) error {
	var err error

	field1IsSet := false

	for _, field := range w.GetStruct().Fields {
		switch field.ID {
		case 1:
			if field.Value.Type() == wire.TMap {
				v.Field1, err = _Map_UUID_Recur2_Read(field.Value.GetMap())
				if err != nil {
					return err
				}
				field1IsSet = true
			}
		}
	}

	if !field1IsSet {
		return errors.New("field Field1 of Recur1 is required")
	}

	return nil
}

func _Map_UUID_Recur2_Encode(val map[UUID]*Recur2, sw stream.Writer) error {

	mh := stream.MapHeader{
		KeyType:   wire.TBinary,
		ValueType: wire.TStruct,
		Length:    len(val),
	}
	if err := sw.WriteMapBegin(mh); err != nil {
		return err
	}

	for k, v := range val {
		if v == nil {
			return fmt.Errorf("invalid map 'map[UUID]*Recur2', key [%v]: value is nil", k)
		}
		if err := k.Encode(sw); err != nil {
			return err
		}
		if err := v.Encode(sw); err != nil {
			return err
		}
	}

	return sw.WriteMapEnd()
}

// Encode serializes a Recur1 struct directly into bytes, without going
// through an intermediary type.
//
// An error is returned if a Recur1 struct could not be encoded.
func (v *Recur1) Encode(sw stream.Writer) error {
	if err := sw.WriteStructBegin(); err != nil {
		return err
	}

	if v.Field1 == nil {
		return errors.New("field Field1 of Recur1 is required")
	}
	if err := sw.WriteFieldBegin(stream.FieldHeader{ID: 1, Type: wire.TMap}); err != nil {
		return err
	}
	if err := _Map_UUID_Recur2_Encode(v.Field1, sw); err != nil {
		return err
	}
	if err := sw.WriteFieldEnd(); err != nil {
		return err
	}

	return sw.WriteStructEnd()
}

func _Recur2_Decode(sr stream.Reader) (*Recur2, error) {
	var v Recur2
	err := v.Decode(sr)
	return &v, err
}

func _Map_UUID_Recur2_Decode(sr stream.Reader) (map[UUID]*Recur2, error) {
	mh, err := sr.ReadMapBegin()
	if err != nil {
		return nil, err
	}

	if mh.KeyType != wire.TBinary || mh.ValueType != wire.TStruct {
		for i := 0; i < mh.Length; i++ {
			if err := sr.Skip(mh.KeyType); err != nil {
				return nil, err
			}

			if err := sr.Skip(mh.ValueType); err != nil {
				return nil, err
			}
		}
		return nil, sr.ReadMapEnd()
	}

	o := make(map[UUID]*Recur2, mh.Length)
	for i := 0; i < mh.Length; i++ {
		k, err := _UUID_Decode(sr)
		if err != nil {
			return nil, err
		}

		v, err := _Recur2_Decode(sr)
		if err != nil {
			return nil, err
		}

		o[k] = v
	}

	if err = sr.ReadMapEnd(); err != nil {
		return nil, err
	}
	return o, err
}

// Decode deserializes a Recur1 struct directly from its Thrift-level
// representation, without going through an intemediary type.
//
// An error is returned if a Recur1 struct could not be generated from the wire
// representation.
func (v *Recur1) Decode(sr stream.Reader) error {

	field1IsSet := false

	if err := sr.ReadStructBegin(); err != nil {
		return err
	}

	fh, ok, err := sr.ReadFieldBegin()
	if err != nil {
		return err
	}

	for ok {
		switch {
		case fh.ID == 1 && fh.Type == wire.TMap:
			v.Field1, err = _Map_UUID_Recur2_Decode(sr)
			if err != nil {
				return err
			}
			field1IsSet = true
		default:
			if err := sr.Skip(fh.Type); err != nil {
				return err
			}
		}

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

		if fh, ok, err = sr.ReadFieldBegin(); err != nil {
			return err
		}
	}

	if err := sr.ReadStructEnd(); err != nil {
		return err
	}

	if !field1IsSet {
		return errors.New("field Field1 of Recur1 is required")
	}

	return nil
}

// String returns a readable string representation of a Recur1
// struct.
func (v *Recur1) String() string {
	if v == nil {
		return "<nil>"
	}

	var fields [1]string
	i := 0
	fields[i] = fmt.Sprintf("Field1: %v", v.Field1)
	i++

	return fmt.Sprintf("Recur1{%v}", strings.Join(fields[:i], ", "))
}

func _Map_UUID_Recur2_Equals(lhs, rhs map[UUID]*Recur2) bool {
	if len(lhs) != len(rhs) {
		return false
	}

	for lk, lv := range lhs {
		rv, ok := rhs[lk]
		if !ok {
			return false
		}
		if !lv.Equals(rv) {
			return false
		}
	}
	return true
}

// Equals returns true if all the fields of this Recur1 match the
// provided Recur1.
//
// This function performs a deep comparison.
func (v *Recur1) Equals(rhs *Recur1) bool {
	if v == nil {
		return rhs == nil
	} else if rhs == nil {
		return false
	}
	if !_Map_UUID_Recur2_Equals(v.Field1, rhs.Field1) {
		return false
	}

	return true
}

type _Map_UUID_Recur2_Zapper map[UUID]*Recur2

// MarshalLogObject implements zapcore.ObjectMarshaler, enabling
// fast logging of _Map_UUID_Recur2_Zapper.
func (m _Map_UUID_Recur2_Zapper) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
	for k, v := range m {
		err = multierr.Append(err, enc.AddObject((string)(k), v))
	}
	return err
}

// MarshalLogObject implements zapcore.ObjectMarshaler, enabling
// fast logging of Recur1.
func (v *Recur1) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
	if v == nil {
		return nil
	}
	err = multierr.Append(err, enc.AddObject("field1", (_Map_UUID_Recur2_Zapper)(v.Field1)))
	return err
}

// GetField1 returns the value of Field1 if it is set or its
// zero value if it is unset.
func (v *Recur1) GetField1() (o map[UUID]*Recur2) {
	if v != nil {
		o = v.Field1
	}
	return
}

// IsSetField1 returns true if Field1 is not nil.
func (v *Recur1) IsSetField1() bool {
	return v != nil && v.Field1 != nil
}

type Recur2 struct {
	Field21 *Recur3 `json:"field21,required"`
	Field22 *Recur3 `json:"field22,required"`
}

// ToWire translates a Recur2 struct into a Thrift-level intermediate
// representation. This intermediate representation may be serialized
// into bytes using a ThriftRW protocol implementation.
//
// An error is returned if the struct or any of its fields failed to
// validate.
//
//	x, err := v.ToWire()
//	if err != nil {
//	  return err
//	}
//
//	if err := binaryProtocol.Encode(x, writer); err != nil {
//	  return err
//	}
func (v *Recur2) ToWire() (wire.Value, error) {
	var (
		fields [2]wire.Field
		i      int = 0
		w      wire.Value
		err    error
	)

	if v.Field21 == nil {
		return w, errors.New("field Field21 of Recur2 is required")
	}
	w, err = v.Field21.ToWire()
	if err != nil {
		return w, err
	}
	fields[i] = wire.Field{ID: 1, Value: w}
	i++
	if v.Field22 == nil {
		return w, errors.New("field Field22 of Recur2 is required")
	}
	w, err = v.Field22.ToWire()
	if err != nil {
		return w, err
	}
	fields[i] = wire.Field{ID: 2, Value: w}
	i++

	return wire.NewValueStruct(wire.Struct{Fields: fields[:i]}), nil
}

func _Recur3_Read(w wire.Value) (*Recur3, error) {
	var v Recur3
	err := v.FromWire(w)
	return &v, err
}

// FromWire deserializes a Recur2 struct from its Thrift-level
// representation. The Thrift-level representation may be obtained
// from a ThriftRW protocol implementation.
//
// An error is returned if we were unable to build a Recur2 struct
// from the provided intermediate representation.
//
//	x, err := binaryProtocol.Decode(reader, wire.TStruct)
//	if err != nil {
//	  return nil, err
//	}
//
//	var v Recur2
//	if err := v.FromWire(x); err != nil {
//	  return nil, err
//	}
//	return &v, nil
func (v *Recur2) FromWire(w wire.Value) error {
	var err error

	field21IsSet := false
	field22IsSet := false

	for _, field := range w.GetStruct().Fields {
		switch field.ID {
		case 1:
			if field.Value.Type() == wire.TStruct {
				v.Field21, err = _Recur3_Read(field.Value)
				if err != nil {
					return err
				}
				field21IsSet = true
			}
		case 2:
			if field.Value.Type() == wire.TStruct {
				v.Field22, err = _Recur3_Read(field.Value)
				if err != nil {
					return err
				}
				field22IsSet = true
			}
		}
	}

	if !field21IsSet {
		return errors.New("field Field21 of Recur2 is required")
	}

	if !field22IsSet {
		return errors.New("field Field22 of Recur2 is required")
	}

	return nil
}

// Encode serializes a Recur2 struct directly into bytes, without going
// through an intermediary type.
//
// An error is returned if a Recur2 struct could not be encoded.
func (v *Recur2) Encode(sw stream.Writer) error {
	if err := sw.WriteStructBegin(); err != nil {
		return err
	}

	if v.Field21 == nil {
		return errors.New("field Field21 of Recur2 is required")
	}
	if err := sw.WriteFieldBegin(stream.FieldHeader{ID: 1, Type: wire.TStruct}); err != nil {
		return err
	}
	if err := v.Field21.Encode(sw); err != nil {
		return err
	}
	if err := sw.WriteFieldEnd(); err != nil {
		return err
	}

	if v.Field22 == nil {
		return errors.New("field Field22 of Recur2 is required")
	}
	if err := sw.WriteFieldBegin(stream.FieldHeader{ID: 2, Type: wire.TStruct}); err != nil {
		return err
	}
	if err := v.Field22.Encode(sw); err != nil {
		return err
	}
	if err := sw.WriteFieldEnd(); err != nil {
		return err
	}

	return sw.WriteStructEnd()
}

func _Recur3_Decode(sr stream.Reader) (*Recur3, error) {
	var v Recur3
	err := v.Decode(sr)
	return &v, err
}

// Decode deserializes a Recur2 struct directly from its Thrift-level
// representation, without going through an intemediary type.
//
// An error is returned if a Recur2 struct could not be generated from the wire
// representation.
func (v *Recur2) Decode(sr stream.Reader) error {

	field21IsSet := false
	field22IsSet := false

	if err := sr.ReadStructBegin(); err != nil {
		return err
	}

	fh, ok, err := sr.ReadFieldBegin()
	if err != nil {
		return err
	}

	for ok {
		switch {
		case fh.ID == 1 && fh.Type == wire.TStruct:
			v.Field21, err = _Recur3_Decode(sr)
			if err != nil {
				return err
			}
			field21IsSet = true
		case fh.ID == 2 && fh.Type == wire.TStruct:
			v.Field22, err = _Recur3_Decode(sr)
			if err != nil {
				return err
			}
			field22IsSet = true
		default:
			if err := sr.Skip(fh.Type); err != nil {
				return err
			}
		}

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

		if fh, ok, err = sr.ReadFieldBegin(); err != nil {
			return err
		}
	}

	if err := sr.ReadStructEnd(); err != nil {
		return err
	}

	if !field21IsSet {
		return errors.New("field Field21 of Recur2 is required")
	}

	if !field22IsSet {
		return errors.New("field Field22 of Recur2 is required")
	}

	return nil
}

// String returns a readable string representation of a Recur2
// struct.
func (v *Recur2) String() string {
	if v == nil {
		return "<nil>"
	}

	var fields [2]string
	i := 0
	fields[i] = fmt.Sprintf("Field21: %v", v.Field21)
	i++
	fields[i] = fmt.Sprintf("Field22: %v", v.Field22)
	i++

	return fmt.Sprintf("Recur2{%v}", strings.Join(fields[:i], ", "))
}

// Equals returns true if all the fields of this Recur2 match the
// provided Recur2.
//
// This function performs a deep comparison.
func (v *Recur2) Equals(rhs *Recur2) bool {
	if v == nil {
		return rhs == nil
	} else if rhs == nil {
		return false
	}
	if !v.Field21.Equals(rhs.Field21) {
		return false
	}
	if !v.Field22.Equals(rhs.Field22) {
		return false
	}

	return true
}

// MarshalLogObject implements zapcore.ObjectMarshaler, enabling
// fast logging of Recur2.
func (v *Recur2) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
	if v == nil {
		return nil
	}
	err = multierr.Append(err, enc.AddObject("field21", v.Field21))
	err = multierr.Append(err, enc.AddObject("field22", v.Field22))
	return err
}

// GetField21 returns the value of Field21 if it is set or its
// zero value if it is unset.
func (v *Recur2) GetField21() (o *Recur3) {
	if v != nil {
		o = v.Field21
	}
	return
}

// IsSetField21 returns true if Field21 is not nil.
func (v *Recur2) IsSetField21() bool {
	return v != nil && v.Field21 != nil
}

// GetField22 returns the value of Field22 if it is set or its
// zero value if it is unset.
func (v *Recur2) GetField22() (o *Recur3) {
	if v != nil {
		o = v.Field22
	}
	return
}

// IsSetField22 returns true if Field22 is not nil.
func (v *Recur2) IsSetField22() bool {
	return v != nil && v.Field22 != nil
}

type Recur3 struct {
	Field31 UUID `json:"field31,required"`
}

// ToWire translates a Recur3 struct into a Thrift-level intermediate
// representation. This intermediate representation may be serialized
// into bytes using a ThriftRW protocol implementation.
//
// An error is returned if the struct or any of its fields failed to
// validate.
//
//	x, err := v.ToWire()
//	if err != nil {
//	  return err
//	}
//
//	if err := binaryProtocol.Encode(x, writer); err != nil {
//	  return err
//	}
func (v *Recur3) ToWire() (wire.Value, error) {
	var (
		fields [1]wire.Field
		i      int = 0
		w      wire.Value
		err    error
	)

	w, err = v.Field31.ToWire()
	if err != nil {
		return w, err
	}
	fields[i] = wire.Field{ID: 1, Value: w}
	i++

	return wire.NewValueStruct(wire.Struct{Fields: fields[:i]}), nil
}

// FromWire deserializes a Recur3 struct from its Thrift-level
// representation. The Thrift-level representation may be obtained
// from a ThriftRW protocol implementation.
//
// An error is returned if we were unable to build a Recur3 struct
// from the provided intermediate representation.
//
//	x, err := binaryProtocol.Decode(reader, wire.TStruct)
//	if err != nil {
//	  return nil, err
//	}
//
//	var v Recur3
//	if err := v.FromWire(x); err != nil {
//	  return nil, err
//	}
//	return &v, nil
func (v *Recur3) FromWire(w wire.Value) error {
	var err error

	field31IsSet := false

	for _, field := range w.GetStruct().Fields {
		switch field.ID {
		case 1:
			if field.Value.Type() == wire.TBinary {
				v.Field31, err = _UUID_Read(field.Value)
				if err != nil {
					return err
				}
				field31IsSet = true
			}
		}
	}

	if !field31IsSet {
		return errors.New("field Field31 of Recur3 is required")
	}

	return nil
}

// Encode serializes a Recur3 struct directly into bytes, without going
// through an intermediary type.
//
// An error is returned if a Recur3 struct could not be encoded.
func (v *Recur3) Encode(sw stream.Writer) error {
	if err := sw.WriteStructBegin(); err != nil {
		return err
	}

	if err := sw.WriteFieldBegin(stream.FieldHeader{ID: 1, Type: wire.TBinary}); err != nil {
		return err
	}
	if err := v.Field31.Encode(sw); err != nil {
		return err
	}
	if err := sw.WriteFieldEnd(); err != nil {
		return err
	}

	return sw.WriteStructEnd()
}

// Decode deserializes a Recur3 struct directly from its Thrift-level
// representation, without going through an intemediary type.
//
// An error is returned if a Recur3 struct could not be generated from the wire
// representation.
func (v *Recur3) Decode(sr stream.Reader) error {

	field31IsSet := false

	if err := sr.ReadStructBegin(); err != nil {
		return err
	}

	fh, ok, err := sr.ReadFieldBegin()
	if err != nil {
		return err
	}

	for ok {
		switch {
		case fh.ID == 1 && fh.Type == wire.TBinary:
			v.Field31, err = _UUID_Decode(sr)
			if err != nil {
				return err
			}
			field31IsSet = true
		default:
			if err := sr.Skip(fh.Type); err != nil {
				return err
			}
		}

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

		if fh, ok, err = sr.ReadFieldBegin(); err != nil {
			return err
		}
	}

	if err := sr.ReadStructEnd(); err != nil {
		return err
	}

	if !field31IsSet {
		return errors.New("field Field31 of Recur3 is required")
	}

	return nil
}

// String returns a readable string representation of a Recur3
// struct.
func (v *Recur3) String() string {
	if v == nil {
		return "<nil>"
	}

	var fields [1]string
	i := 0
	fields[i] = fmt.Sprintf("Field31: %v", v.Field31)
	i++

	return fmt.Sprintf("Recur3{%v}", strings.Join(fields[:i], ", "))
}

// Equals returns true if all the fields of this Recur3 match the
// provided Recur3.
//
// This function performs a deep comparison.
func (v *Recur3) Equals(rhs *Recur3) bool {
	if v == nil {
		return rhs == nil
	} else if rhs == nil {
		return false
	}
	if !(v.Field31 == rhs.Field31) {
		return false
	}

	return true
}

// MarshalLogObject implements zapcore.ObjectMarshaler, enabling
// fast logging of Recur3.
func (v *Recur3) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
	if v == nil {
		return nil
	}
	enc.AddString("field31", (string)(v.Field31))
	return err
}

// GetField31 returns the value of Field31 if it is set or its
// zero value if it is unset.
func (v *Recur3) GetField31() (o UUID) {
	if v != nil {
		o = v.Field31
	}
	return
}

type ServerErr struct {
	Message string `json:"message,required"`
}

// ToWire translates a ServerErr struct into a Thrift-level intermediate
// representation. This intermediate representation may be serialized
// into bytes using a ThriftRW protocol implementation.
//
// An error is returned if the struct or any of its fields failed to
// validate.
//
//	x, err := v.ToWire()
//	if err != nil {
//	  return err
//	}
//
//	if err := binaryProtocol.Encode(x, writer); err != nil {
//	  return err
//	}
func (v *ServerErr) ToWire() (wire.Value, error) {
	var (
		fields [1]wire.Field
		i      int = 0
		w      wire.Value
		err    error
	)

	w, err = wire.NewValueString(v.Message), error(nil)
	if err != nil {
		return w, err
	}
	fields[i] = wire.Field{ID: 1, Value: w}
	i++

	return wire.NewValueStruct(wire.Struct{Fields: fields[:i]}), nil
}

// FromWire deserializes a ServerErr struct from its Thrift-level
// representation. The Thrift-level representation may be obtained
// from a ThriftRW protocol implementation.
//
// An error is returned if we were unable to build a ServerErr struct
// from the provided intermediate representation.
//
//	x, err := binaryProtocol.Decode(reader, wire.TStruct)
//	if err != nil {
//	  return nil, err
//	}
//
//	var v ServerErr
//	if err := v.FromWire(x); err != nil {
//	  return nil, err
//	}
//	return &v, nil
func (v *ServerErr) FromWire(w wire.Value) error {
	var err error

	messageIsSet := false

	for _, field := range w.GetStruct().Fields {
		switch field.ID {
		case 1:
			if field.Value.Type() == wire.TBinary {
				v.Message, err = field.Value.GetString(), error(nil)
				if err != nil {
					return err
				}
				messageIsSet = true
			}
		}
	}

	if !messageIsSet {
		return errors.New("field Message of ServerErr is required")
	}

	return nil
}

// Encode serializes a ServerErr struct directly into bytes, without going
// through an intermediary type.
//
// An error is returned if a ServerErr struct could not be encoded.
func (v *ServerErr) Encode(sw stream.Writer) error {
	if err := sw.WriteStructBegin(); err != nil {
		return err
	}

	if err := sw.WriteFieldBegin(stream.FieldHeader{ID: 1, Type: wire.TBinary}); err != nil {
		return err
	}
	if err := sw.WriteString(v.Message); err != nil {
		return err
	}
	if err := sw.WriteFieldEnd(); err != nil {
		return err
	}

	return sw.WriteStructEnd()
}

// Decode deserializes a ServerErr struct directly from its Thrift-level
// representation, without going through an intemediary type.
//
// An error is returned if a ServerErr struct could not be generated from the wire
// representation.
func (v *ServerErr) Decode(sr stream.Reader) error {

	messageIsSet := false

	if err := sr.ReadStructBegin(); err != nil {
		return err
	}

	fh, ok, err := sr.ReadFieldBegin()
	if err != nil {
		return err
	}

	for ok {
		switch {
		case fh.ID == 1 && fh.Type == wire.TBinary:
			v.Message, err = sr.ReadString()
			if err != nil {
				return err
			}
			messageIsSet = true
		default:
			if err := sr.Skip(fh.Type); err != nil {
				return err
			}
		}

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

		if fh, ok, err = sr.ReadFieldBegin(); err != nil {
			return err
		}
	}

	if err := sr.ReadStructEnd(); err != nil {
		return err
	}

	if !messageIsSet {
		return errors.New("field Message of ServerErr is required")
	}

	return nil
}

// String returns a readable string representation of a ServerErr
// struct.
func (v *ServerErr) String() string {
	if v == nil {
		return "<nil>"
	}

	var fields [1]string
	i := 0
	fields[i] = fmt.Sprintf("Message: %v", v.Message)
	i++

	return fmt.Sprintf("ServerErr{%v}", strings.Join(fields[:i], ", "))
}

// ErrorName is the name of this type as defined in the Thrift
// file.
func (*ServerErr) ErrorName() string {
	return "ServerErr"
}

// Equals returns true if all the fields of this ServerErr match the
// provided ServerErr.
//
// This function performs a deep comparison.
func (v *ServerErr) Equals(rhs *ServerErr) bool {
	if v == nil {
		return rhs == nil
	} else if rhs == nil {
		return false
	}
	if !(v.Message == rhs.Message) {
		return false
	}

	return true
}

// MarshalLogObject implements zapcore.ObjectMarshaler, enabling
// fast logging of ServerErr.
func (v *ServerErr) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
	if v == nil {
		return nil
	}
	enc.AddString("message", v.Message)
	return err
}

// GetMessage returns the value of Message if it is set or its
// zero value if it is unset.
func (v *ServerErr) GetMessage() (o string) {
	if v != nil {
		o = v.Message
	}
	return
}

func (v *ServerErr) Error() string {
	return v.String()
}

type TransHeader struct {
}

// ToWire translates a TransHeader struct into a Thrift-level intermediate
// representation. This intermediate representation may be serialized
// into bytes using a ThriftRW protocol implementation.
//
// An error is returned if the struct or any of its fields failed to
// validate.
//
//	x, err := v.ToWire()
//	if err != nil {
//	  return err
//	}
//
//	if err := binaryProtocol.Encode(x, writer); err != nil {
//	  return err
//	}
func (v *TransHeader) ToWire() (wire.Value, error) {
	var (
		fields [0]wire.Field
		i      int = 0
	)

	return wire.NewValueStruct(wire.Struct{Fields: fields[:i]}), nil
}

// FromWire deserializes a TransHeader struct from its Thrift-level
// representation. The Thrift-level representation may be obtained
// from a ThriftRW protocol implementation.
//
// An error is returned if we were unable to build a TransHeader struct
// from the provided intermediate representation.
//
//	x, err := binaryProtocol.Decode(reader, wire.TStruct)
//	if err != nil {
//	  return nil, err
//	}
//
//	var v TransHeader
//	if err := v.FromWire(x); err != nil {
//	  return nil, err
//	}
//	return &v, nil
func (v *TransHeader) FromWire(w wire.Value) error {

	for _, field := range w.GetStruct().Fields {
		switch field.ID {
		}
	}

	return nil
}

// Encode serializes a TransHeader struct directly into bytes, without going
// through an intermediary type.
//
// An error is returned if a TransHeader struct could not be encoded.
func (v *TransHeader) Encode(sw stream.Writer) error {
	if err := sw.WriteStructBegin(); err != nil {
		return err
	}

	return sw.WriteStructEnd()
}

// Decode deserializes a TransHeader struct directly from its Thrift-level
// representation, without going through an intemediary type.
//
// An error is returned if a TransHeader struct could not be generated from the wire
// representation.
func (v *TransHeader) Decode(sr stream.Reader) error {

	if err := sr.ReadStructBegin(); err != nil {
		return err
	}

	fh, ok, err := sr.ReadFieldBegin()
	if err != nil {
		return err
	}

	for ok {
		switch {
		default:
			if err := sr.Skip(fh.Type); err != nil {
				return err
			}
		}

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

		if fh, ok, err = sr.ReadFieldBegin(); err != nil {
			return err
		}
	}

	if err := sr.ReadStructEnd(); err != nil {
		return err
	}

	return nil
}

// String returns a readable string representation of a TransHeader
// struct.
func (v *TransHeader) String() string {
	if v == nil {
		return "<nil>"
	}

	var fields [0]string
	i := 0

	return fmt.Sprintf("TransHeader{%v}", strings.Join(fields[:i], ", "))
}

// Equals returns true if all the fields of this TransHeader match the
// provided TransHeader.
//
// This function performs a deep comparison.
func (v *TransHeader) Equals(rhs *TransHeader) bool {
	if v == nil {
		return rhs == nil
	} else if rhs == nil {
		return false
	}

	return true
}

// MarshalLogObject implements zapcore.ObjectMarshaler, enabling
// fast logging of TransHeader.
func (v *TransHeader) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
	if v == nil {
		return nil
	}
	return err
}

type TransStruct struct {
	Message string        `json:"message,required"`
	Driver  *NestedStruct `json:"driver,omitempty"`
	Rider   *NestedStruct `json:"rider,required"`
}

// ToWire translates a TransStruct struct into a Thrift-level intermediate
// representation. This intermediate representation may be serialized
// into bytes using a ThriftRW protocol implementation.
//
// An error is returned if the struct or any of its fields failed to
// validate.
//
//	x, err := v.ToWire()
//	if err != nil {
//	  return err
//	}
//
//	if err := binaryProtocol.Encode(x, writer); err != nil {
//	  return err
//	}
func (v *TransStruct) ToWire() (wire.Value, error) {
	var (
		fields [3]wire.Field
		i      int = 0
		w      wire.Value
		err    error
	)

	w, err = wire.NewValueString(v.Message), error(nil)
	if err != nil {
		return w, err
	}
	fields[i] = wire.Field{ID: 1, Value: w}
	i++
	if v.Driver != nil {
		w, err = v.Driver.ToWire()
		if err != nil {
			return w, err
		}
		fields[i] = wire.Field{ID: 2, Value: w}
		i++
	}
	if v.Rider == nil {
		return w, errors.New("field Rider of TransStruct is required")
	}
	w, err = v.Rider.ToWire()
	if err != nil {
		return w, err
	}
	fields[i] = wire.Field{ID: 3, Value: w}
	i++

	return wire.NewValueStruct(wire.Struct{Fields: fields[:i]}), nil
}

func _NestedStruct_Read(w wire.Value) (*NestedStruct, error) {
	var v NestedStruct
	err := v.FromWire(w)
	return &v, err
}

// FromWire deserializes a TransStruct struct from its Thrift-level
// representation. The Thrift-level representation may be obtained
// from a ThriftRW protocol implementation.
//
// An error is returned if we were unable to build a TransStruct struct
// from the provided intermediate representation.
//
//	x, err := binaryProtocol.Decode(reader, wire.TStruct)
//	if err != nil {
//	  return nil, err
//	}
//
//	var v TransStruct
//	if err := v.FromWire(x); err != nil {
//	  return nil, err
//	}
//	return &v, nil
func (v *TransStruct) FromWire(w wire.Value) error {
	var err error

	messageIsSet := false

	riderIsSet := false

	for _, field := range w.GetStruct().Fields {
		switch field.ID {
		case 1:
			if field.Value.Type() == wire.TBinary {
				v.Message, err = field.Value.GetString(), error(nil)
				if err != nil {
					return err
				}
				messageIsSet = true
			}
		case 2:
			if field.Value.Type() == wire.TStruct {
				v.Driver, err = _NestedStruct_Read(field.Value)
				if err != nil {
					return err
				}

			}
		case 3:
			if field.Value.Type() == wire.TStruct {
				v.Rider, err = _NestedStruct_Read(field.Value)
				if err != nil {
					return err
				}
				riderIsSet = true
			}
		}
	}

	if !messageIsSet {
		return errors.New("field Message of TransStruct is required")
	}

	if !riderIsSet {
		return errors.New("field Rider of TransStruct is required")
	}

	return nil
}

// Encode serializes a TransStruct struct directly into bytes, without going
// through an intermediary type.
//
// An error is returned if a TransStruct struct could not be encoded.
func (v *TransStruct) Encode(sw stream.Writer) error {
	if err := sw.WriteStructBegin(); err != nil {
		return err
	}

	if err := sw.WriteFieldBegin(stream.FieldHeader{ID: 1, Type: wire.TBinary}); err != nil {
		return err
	}
	if err := sw.WriteString(v.Message); err != nil {
		return err
	}
	if err := sw.WriteFieldEnd(); err != nil {
		return err
	}

	if v.Driver != nil {
		if err := sw.WriteFieldBegin(stream.FieldHeader{ID: 2, Type: wire.TStruct}); err != nil {
			return err
		}
		if err := v.Driver.Encode(sw); err != nil {
			return err
		}
		if err := sw.WriteFieldEnd(); err != nil {
			return err
		}
	}

	if v.Rider == nil {
		return errors.New("field Rider of TransStruct is required")
	}
	if err := sw.WriteFieldBegin(stream.FieldHeader{ID: 3, Type: wire.TStruct}); err != nil {
		return err
	}
	if err := v.Rider.Encode(sw); err != nil {
		return err
	}
	if err := sw.WriteFieldEnd(); err != nil {
		return err
	}

	return sw.WriteStructEnd()
}

func _NestedStruct_Decode(sr stream.Reader) (*NestedStruct, error) {
	var v NestedStruct
	err := v.Decode(sr)
	return &v, err
}

// Decode deserializes a TransStruct struct directly from its Thrift-level
// representation, without going through an intemediary type.
//
// An error is returned if a TransStruct struct could not be generated from the wire
// representation.
func (v *TransStruct) Decode(sr stream.Reader) error {

	messageIsSet := false

	riderIsSet := false

	if err := sr.ReadStructBegin(); err != nil {
		return err
	}

	fh, ok, err := sr.ReadFieldBegin()
	if err != nil {
		return err
	}

	for ok {
		switch {
		case fh.ID == 1 && fh.Type == wire.TBinary:
			v.Message, err = sr.ReadString()
			if err != nil {
				return err
			}
			messageIsSet = true
		case fh.ID == 2 && fh.Type == wire.TStruct:
			v.Driver, err = _NestedStruct_Decode(sr)
			if err != nil {
				return err
			}

		case fh.ID == 3 && fh.Type == wire.TStruct:
			v.Rider, err = _NestedStruct_Decode(sr)
			if err != nil {
				return err
			}
			riderIsSet = true
		default:
			if err := sr.Skip(fh.Type); err != nil {
				return err
			}
		}

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

		if fh, ok, err = sr.ReadFieldBegin(); err != nil {
			return err
		}
	}

	if err := sr.ReadStructEnd(); err != nil {
		return err
	}

	if !messageIsSet {
		return errors.New("field Message of TransStruct is required")
	}

	if !riderIsSet {
		return errors.New("field Rider of TransStruct is required")
	}

	return nil
}

// String returns a readable string representation of a TransStruct
// struct.
func (v *TransStruct) String() string {
	if v == nil {
		return "<nil>"
	}

	var fields [3]string
	i := 0
	fields[i] = fmt.Sprintf("Message: %v", v.Message)
	i++
	if v.Driver != nil {
		fields[i] = fmt.Sprintf("Driver: %v", v.Driver)
		i++
	}
	fields[i] = fmt.Sprintf("Rider: %v", v.Rider)
	i++

	return fmt.Sprintf("TransStruct{%v}", strings.Join(fields[:i], ", "))
}

// Equals returns true if all the fields of this TransStruct match the
// provided TransStruct.
//
// This function performs a deep comparison.
func (v *TransStruct) Equals(rhs *TransStruct) bool {
	if v == nil {
		return rhs == nil
	} else if rhs == nil {
		return false
	}
	if !(v.Message == rhs.Message) {
		return false
	}
	if !((v.Driver == nil && rhs.Driver == nil) || (v.Driver != nil && rhs.Driver != nil && v.Driver.Equals(rhs.Driver))) {
		return false
	}
	if !v.Rider.Equals(rhs.Rider) {
		return false
	}

	return true
}

// MarshalLogObject implements zapcore.ObjectMarshaler, enabling
// fast logging of TransStruct.
func (v *TransStruct) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
	if v == nil {
		return nil
	}
	enc.AddString("message", v.Message)
	if v.Driver != nil {
		err = multierr.Append(err, enc.AddObject("driver", v.Driver))
	}
	err = multierr.Append(err, enc.AddObject("rider", v.Rider))
	return err
}

// GetMessage returns the value of Message if it is set or its
// zero value if it is unset.
func (v *TransStruct) GetMessage() (o string) {
	if v != nil {
		o = v.Message
	}
	return
}

// GetDriver returns the value of Driver if it is set or its
// zero value if it is unset.
func (v *TransStruct) GetDriver() (o *NestedStruct) {
	if v != nil && v.Driver != nil {
		return v.Driver
	}

	return
}

// IsSetDriver returns true if Driver is not nil.
func (v *TransStruct) IsSetDriver() bool {
	return v != nil && v.Driver != nil
}

// GetRider returns the value of Rider if it is set or its
// zero value if it is unset.
func (v *TransStruct) GetRider() (o *NestedStruct) {
	if v != nil {
		o = v.Rider
	}
	return
}

// IsSetRider returns true if Rider is not nil.
func (v *TransStruct) IsSetRider() bool {
	return v != nil && v.Rider != nil
}

type UUID string

// UUIDPtr returns a pointer to a UUID
func (v UUID) Ptr() *UUID {
	return &v
}

// ToWire translates UUID into a Thrift-level intermediate
// representation. This intermediate representation may be serialized
// into bytes using a ThriftRW protocol implementation.
func (v UUID) ToWire() (wire.Value, error) {
	x := (string)(v)
	return wire.NewValueString(x), error(nil)
}

// String returns a readable string representation of UUID.
func (v UUID) String() string {
	x := (string)(v)
	return fmt.Sprint(x)
}

func (v UUID) Encode(sw stream.Writer) error {
	x := (string)(v)
	return sw.WriteString(x)
}

// FromWire deserializes UUID from its Thrift-level
// representation. The Thrift-level representation may be obtained
// from a ThriftRW protocol implementation.
func (v *UUID) FromWire(w wire.Value) error {
	x, err := w.GetString(), error(nil)
	*v = (UUID)(x)
	return err
}

// Decode deserializes UUID directly off the wire.
func (v *UUID) Decode(sr stream.Reader) error {
	x, err := sr.ReadString()
	*v = (UUID)(x)
	return err
}

// Equals returns true if this UUID is equal to the provided
// UUID.
func (lhs UUID) Equals(rhs UUID) bool {
	return ((string)(lhs) == (string)(rhs))
}

// SimpleService_AnotherCall_Args represents the arguments for the SimpleService.anotherCall function.
//
// The arguments for anotherCall are sent and received over the wire as this struct.
type SimpleService_AnotherCall_Args struct {
	Arg         *BazRequest `json:"arg,required"`
	I64Optional *int64      `json:"i64Optional,omitempty"`
	TestUUID    *UUID       `json:"testUUID,omitempty"`
}

// ToWire translates a SimpleService_AnotherCall_Args struct into a Thrift-level intermediate
// representation. This intermediate representation may be serialized
// into bytes using a ThriftRW protocol implementation.
//
// An error is returned if the struct or any of its fields failed to
// validate.
//
//	x, err := v.ToWire()
//	if err != nil {
//	  return err
//	}
//
//	if err := binaryProtocol.Encode(x, writer); err != nil {
//	  return err
//	}
func (v *SimpleService_AnotherCall_Args) ToWire() (wire.Value, error) {
	var (
		fields [3]wire.Field
		i      int = 0
		w      wire.Value
		err    error
	)

	if v.Arg == nil {
		return w, errors.New("field Arg of SimpleService_AnotherCall_Args is required")
	}
	w, err = v.Arg.ToWire()
	if err != nil {
		return w, err
	}
	fields[i] = wire.Field{ID: 1, Value: w}
	i++
	if v.I64Optional != nil {
		w, err = wire.NewValueI64(*(v.I64Optional)), error(nil)
		if err != nil {
			return w, err
		}
		fields[i] = wire.Field{ID: 2, Value: w}
		i++
	}
	if v.TestUUID != nil {
		w, err = v.TestUUID.ToWire()
		if err != nil {
			return w, err
		}
		fields[i] = wire.Field{ID: 3, Value: w}
		i++
	}

	return wire.NewValueStruct(wire.Struct{Fields: fields[:i]}), nil
}

func _BazRequest_Read(w wire.Value) (*BazRequest, error) {
	var v BazRequest
	err := v.FromWire(w)
	return &v, err
}

// FromWire deserializes a SimpleService_AnotherCall_Args struct from its Thrift-level
// representation. The Thrift-level representation may be obtained
// from a ThriftRW protocol implementation.
//
// An error is returned if we were unable to build a SimpleService_AnotherCall_Args struct
// from the provided intermediate representation.
//
//	x, err := binaryProtocol.Decode(reader, wire.TStruct)
//	if err != nil {
//	  return nil, err
//	}
//
//	var v SimpleService_AnotherCall_Args
//	if err := v.FromWire(x); err != nil {
//	  return nil, err
//	}
//	return &v, nil
func (v *SimpleService_AnotherCall_Args) FromWire(w wire.Value) error {
	var err error

	argIsSet := false

	for _, field := range w.GetStruct().Fields {
		switch field.ID {
		case 1:
			if field.Value.Type() == wire.TStruct {
				v.Arg, err = _BazRequest_Read(field.Value)
				if err != nil {
					return err
				}
				argIsSet = true
			}
		case 2:
			if field.Value.Type() == wire.TI64 {
				var x int64
				x, err = field.Value.GetI64(), error(nil)
				v.I64Optional = &x
				if err != nil {
					return err
				}

			}
		case 3:
			if field.Value.Type() == wire.TBinary {
				var x UUID
				x, err = _UUID_Read(field.Value)
				v.TestUUID = &x
				if err != nil {
					return err
				}

			}
		}
	}

	if !argIsSet {
		return errors.New("field Arg of SimpleService_AnotherCall_Args is required")
	}

	return nil
}

// Encode serializes a SimpleService_AnotherCall_Args struct directly into bytes, without going
// through an intermediary type.
//
// An error is returned if a SimpleService_AnotherCall_Args struct could not be encoded.
func (v *SimpleService_AnotherCall_Args) Encode(sw stream.Writer) error {
	if err := sw.WriteStructBegin(); err != nil {
		return err
	}

	if v.Arg == nil {
		return errors.New("field Arg of SimpleService_AnotherCall_Args is required")
	}
	if err := sw.WriteFieldBegin(stream.FieldHeader{ID: 1, Type: wire.TStruct}); err != nil {
		return err
	}
	if err := v.Arg.Encode(sw); err != nil {
		return err
	}
	if err := sw.WriteFieldEnd(); err != nil {
		return err
	}

	if v.I64Optional != nil {
		if err := sw.WriteFieldBegin(stream.FieldHeader{ID: 2, Type: wire.TI64}); err != nil {
			return err
		}
		if err := sw.WriteInt64(*(v.I64Optional)); err != nil {
			return err
		}
		if err := sw.WriteFieldEnd(); err != nil {
			return err
		}
	}

	if v.TestUUID != nil {
		if err := sw.WriteFieldBegin(stream.FieldHeader{ID: 3, Type: wire.TBinary}); err != nil {
			return err
		}
		if err := v.TestUUID.Encode(sw); err != nil {
			return err
		}
		if err := sw.WriteFieldEnd(); err != nil {
			return err
		}
	}

	return sw.WriteStructEnd()
}

func _BazRequest_Decode(sr stream.Reader) (*BazRequest, error) {
	var v BazRequest
	err := v.Decode(sr)
	return &v, err
}

// Decode deserializes a SimpleService_AnotherCall_Args struct directly from its Thrift-level
// representation, without going through an intemediary type.
//
// An error is returned if a SimpleService_AnotherCall_Args struct could not be generated from the wire
// representation.
func (v *SimpleService_AnotherCall_Args) Decode(sr stream.Reader) error {

	argIsSet := false

	if err := sr.ReadStructBegin(); err != nil {
		return err
	}

	fh, ok, err := sr.ReadFieldBegin()
	if err != nil {
		return err
	}

	for ok {
		switch {
		case fh.ID == 1 && fh.Type == wire.TStruct:
			v.Arg, err = _BazRequest_Decode(sr)
			if err != nil {
				return err
			}
			argIsSet = true
		case fh.ID == 2 && fh.Type == wire.TI64:
			var x int64
			x, err = sr.ReadInt64()
			v.I64Optional = &x
			if err != nil {
				return err
			}

		case fh.ID == 3 && fh.Type == wire.TBinary:
			var x UUID
			x, err = _UUID_Decode(sr)
			v.TestUUID = &x
			if err != nil {
				return err
			}

		default:
			if err := sr.Skip(fh.Type); err != nil {
				return err
			}
		}

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

		if fh, ok, err = sr.ReadFieldBegin(); err != nil {
			return err
		}
	}

	if err := sr.ReadStructEnd(); err != nil {
		return err
	}

	if !argIsSet {
		return errors.New("field Arg of SimpleService_AnotherCall_Args is required")
	}

	return nil
}

// String returns a readable string representation of a SimpleService_AnotherCall_Args
// struct.
func (v *SimpleService_AnotherCall_Args) String() string {
	if v == nil {
		return "<nil>"
	}

	var fields [3]string
	i := 0
	fields[i] = fmt.Sprintf("Arg: %v", v.Arg)
	i++
	if v.I64Optional != nil {
		fields[i] = fmt.Sprintf("I64Optional: %v", *(v.I64Optional))
		i++
	}
	if v.TestUUID != nil {
		fields[i] = fmt.Sprintf("TestUUID: %v", *(v.TestUUID))
		i++
	}

	return fmt.Sprintf("SimpleService_AnotherCall_Args{%v}", strings.Join(fields[:i], ", "))
}

func _I64_EqualsPtr(lhs, rhs *int64) bool {
	if lhs != nil && rhs != nil {

		x := *lhs
		y := *rhs
		return (x == y)
	}
	return lhs == nil && rhs == nil
}

func _UUID_EqualsPtr(lhs, rhs *UUID) bool {
	if lhs != nil && rhs != nil {

		x := *lhs
		y := *rhs
		return (x == y)
	}
	return lhs == nil && rhs == nil
}

// Equals returns true if all the fields of this SimpleService_AnotherCall_Args match the
// provided SimpleService_AnotherCall_Args.
//
// This function performs a deep comparison.
func (v *SimpleService_AnotherCall_Args) Equals(rhs *SimpleService_AnotherCall_Args) bool {
	if v == nil {
		return rhs == nil
	} else if rhs == nil {
		return false
	}
	if !v.Arg.Equals(rhs.Arg) {
		return false
	}
	if !_I64_EqualsPtr(v.I64Optional, rhs.I64Optional) {
		return false
	}
	if !_UUID_EqualsPtr(v.TestUUID, rhs.TestUUID) {
		return false
	}

	return true
}

// MarshalLogObject implements zapcore.ObjectMarshaler, enabling
// fast logging of SimpleService_AnotherCall_Args.
func (v *SimpleService_AnotherCall_Args) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
	if v == nil {
		return nil
	}
	err = multierr.Append(err, enc.AddObject("arg", v.Arg))
	if v.I64Optional != nil {
		enc.AddInt64("i64Optional", *v.I64Optional)
	}
	if v.TestUUID != nil {
		enc.AddString("testUUID", (string)(*v.TestUUID))
	}
	return err
}

// GetArg returns the value of Arg if it is set or its
// zero value if it is unset.
func (v *SimpleService_AnotherCall_Args) GetArg() (o *BazRequest) {
	if v != nil {
		o = v.Arg
	}
	return
}

// IsSetArg returns true if Arg is not nil.
func (v *SimpleService_AnotherCall_Args) IsSetArg() bool {
	return v != nil && v.Arg != nil
}

// GetI64Optional returns the value of I64Optional if it is set or its
// zero value if it is unset.
func (v *SimpleService_AnotherCall_Args) GetI64Optional() (o int64) {
	if v != nil && v.I64Optional != nil {
		return *v.I64Optional
	}

	return
}

// IsSetI64Optional returns true if I64Optional is not nil.
func (v *SimpleService_AnotherCall_Args) IsSetI64Optional() bool {
	return v != nil && v.I64Optional != nil
}

// GetTestUUID returns the value of TestUUID if it is set or its
// zero value if it is unset.
func (v *SimpleService_AnotherCall_Args) GetTestUUID() (o UUID) {
	if v != nil && v.TestUUID != nil {
		return *v.TestUUID
	}

	return
}

// IsSetTestUUID returns true if TestUUID is not nil.
func (v *SimpleService_AnotherCall_Args) IsSetTestUUID() bool {
	return v != nil && v.TestUUID != nil
}

// MethodName returns the name of the Thrift function as specified in
// the IDL, for which this struct represent the arguments.
//
// This will always be "anotherCall" for this struct.
func (v *SimpleService_AnotherCall_Args) MethodName() string {
	return "anotherCall"
}

// EnvelopeType returns the kind of value inside this struct.
//
// This will always be Call for this struct.
func (v *SimpleService_AnotherCall_Args) EnvelopeType() wire.EnvelopeType {
	return wire.Call
}

// SimpleService_AnotherCall_Helper provides functions that aid in handling the
// parameters and return values of the SimpleService.anotherCall
// function.
var SimpleService_AnotherCall_Helper = struct {
	// Args accepts the parameters of anotherCall in-order and returns
	// the arguments struct for the function.
	Args func(
		arg *BazRequest,
		i64Optional *int64,
		testUUID *UUID,
	) *SimpleService_AnotherCall_Args

	// IsException returns true if the given error can be thrown
	// by anotherCall.
	//
	// An error can be thrown by anotherCall only if the
	// corresponding exception type was mentioned in the 'throws'
	// section for it in the Thrift file.
	IsException func(error) bool

	// WrapResponse returns the result struct for anotherCall
	// given the error returned by it. The provided error may
	// be nil if anotherCall did not fail.
	//
	// This allows mapping errors returned by anotherCall into a
	// serializable result struct. WrapResponse returns a
	// non-nil error if the provided error cannot be thrown by
	// anotherCall
	//
	//   err := anotherCall(args)
	//   result, err := SimpleService_AnotherCall_Helper.WrapResponse(err)
	//   if err != nil {
	//     return fmt.Errorf("unexpected error from anotherCall: %v", err)
	//   }
	//   serialize(result)
	WrapResponse func(error) (*SimpleService_AnotherCall_Result, error)

	// UnwrapResponse takes the result struct for anotherCall
	// and returns the erorr returned by it (if any).
	//
	// The error is non-nil only if anotherCall threw an
	// exception.
	//
	//   result := deserialize(bytes)
	//   err := SimpleService_AnotherCall_Helper.UnwrapResponse(result)
	UnwrapResponse func(*SimpleService_AnotherCall_Result) error
}{}

func init() {
	SimpleService_AnotherCall_Helper.Args = func(
		arg *BazRequest,
		i64Optional *int64,
		testUUID *UUID,
	) *SimpleService_AnotherCall_Args {
		return &SimpleService_AnotherCall_Args{
			Arg:         arg,
			I64Optional: i64Optional,
			TestUUID:    testUUID,
		}
	}

	SimpleService_AnotherCall_Helper.IsException = func(err error) bool {
		switch err.(type) {
		case *AuthErr:
			return true
		default:
			return false
		}
	}

	SimpleService_AnotherCall_Helper.WrapResponse = func(err error) (*SimpleService_AnotherCall_Result, error) {
		if err == nil {
			return &SimpleService_AnotherCall_Result{}, nil
		}

		switch e := err.(type) {
		case *AuthErr:
			if e == nil {
				return nil, errors.New("WrapResponse received non-nil error type with nil value for SimpleService_AnotherCall_Result.AuthErr")
			}
			return &SimpleService_AnotherCall_Result{AuthErr: e}, nil
		}

		return nil, err
	}
	SimpleService_AnotherCall_Helper.UnwrapResponse = func(result *SimpleService_AnotherCall_Result) (err error) {
		if result.AuthErr != nil {
			err = result.AuthErr
			return
		}
		return
	}

}

// SimpleService_AnotherCall_Result represents the result of a SimpleService.anotherCall function call.
//
// The result of a anotherCall execution is sent and received over the wire as this struct.
type SimpleService_AnotherCall_Result struct {
	AuthErr *AuthErr `json:"authErr,omitempty"`
}

// ToWire translates a SimpleService_AnotherCall_Result struct into a Thrift-level intermediate
// representation. This intermediate representation may be serialized
// into bytes using a ThriftRW protocol implementation.
//
// An error is returned if the struct or any of its fields failed to
// validate.
//
//	x, err := v.ToWire()
//	if err != nil {
//	  return err
//	}
//
//	if err := binaryProtocol.Encode(x, writer); err != nil {
//	  return err
//	}
func (v *SimpleService_AnotherCall_Result) ToWire() (wire.Value, error) {
	var (
		fields [1]wire.Field
		i      int = 0
		w      wire.Value
		err    error
	)

	if v.AuthErr != nil {
		w, err = v.AuthErr.ToWire()
		if err != nil {
			return w, err
		}
		fields[i] = wire.Field{ID: 1, Value: w}
		i++
	}

	if i > 1 {
		return wire.Value{}, fmt.Errorf("SimpleService_AnotherCall_Result should have at most one field: got %v fields", i)
	}

	return wire.NewValueStruct(wire.Struct{Fields: fields[:i]}), nil
}

func _AuthErr_Read(w wire.Value) (*AuthErr, error) {
	var v AuthErr
	err := v.FromWire(w)
	return &v, err
}

// FromWire deserializes a SimpleService_AnotherCall_Result struct from its Thrift-level
// representation. The Thrift-level representation may be obtained
// from a ThriftRW protocol implementation.
//
// An error is returned if we were unable to build a SimpleService_AnotherCall_Result struct
// from the provided intermediate representation.
//
//	x, err := binaryProtocol.Decode(reader, wire.TStruct)
//	if err != nil {
//	  return nil, err
//	}
//
//	var v SimpleService_AnotherCall_Result
//	if err := v.FromWire(x); err != nil {
//	  return nil, err
//	}
//	return &v, nil
func (v *SimpleService_AnotherCall_Result) FromWire(w wire.Value) error {
	var err error

	for _, field := range w.GetStruct().Fields {
		switch field.ID {
		case 1:
			if field.Value.Type() == wire.TStruct {
				v.AuthErr, err = _AuthErr_Read(field.Value)
				if err != nil {
					return err
				}

			}
		}
	}

	count := 0
	if v.AuthErr != nil {
		count++
	}
	if count > 1 {
		return fmt.Errorf("SimpleService_AnotherCall_Result should have at most one field: got %v fields", count)
	}

	return nil
}

// Encode serializes a SimpleService_AnotherCall_Result struct directly into bytes, without going
// through an intermediary type.
//
// An error is returned if a SimpleService_AnotherCall_Result struct could not be encoded.
func (v *SimpleService_AnotherCall_Result) Encode(sw stream.Writer) error {
	if err := sw.WriteStructBegin(); err != nil {
		return err
	}

	if v.AuthErr != nil {
		if err := sw.WriteFieldBegin(stream.FieldHeader{ID: 1, Type: wire.TStruct}); err != nil {
			return err
		}
		if err := v.AuthErr.Encode(sw); err != nil {
			return err
		}
		if err := sw.WriteFieldEnd(); err != nil {
			return err
		}
	}

	count := 0
	if v.AuthErr != nil {
		count++
	}

	if count > 1 {
		return fmt.Errorf("SimpleService_AnotherCall_Result should have at most one field: got %v fields", count)
	}

	return sw.WriteStructEnd()
}

func _AuthErr_Decode(sr stream.Reader) (*AuthErr, error) {
	var v AuthErr
	err := v.Decode(sr)
	return &v, err
}

// Decode deserializes a SimpleService_AnotherCall_Result struct directly from its Thrift-level
// representation, without going through an intemediary type.
//
// An error is returned if a SimpleService_AnotherCall_Result struct could not be generated from the wire
// representation.
func (v *SimpleService_AnotherCall_Result) Decode(sr stream.Reader) error {

	if err := sr.ReadStructBegin(); err != nil {
		return err
	}

	fh, ok, err := sr.ReadFieldBegin()
	if err != nil {
		return err
	}

	for ok {
		switch {
		case fh.ID == 1 && fh.Type == wire.TStruct:
			v.AuthErr, err = _AuthErr_Decode(sr)
			if err != nil {
				return err
			}

		default:
			if err := sr.Skip(fh.Type); err != nil {
				return err
			}
		}

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

		if fh, ok, err = sr.ReadFieldBegin(); err != nil {
			return err
		}
	}

	if err := sr.ReadStructEnd(); err != nil {
		return err
	}

	count := 0
	if v.AuthErr != nil {
		count++
	}
	if count > 1 {
		return fmt.Errorf("SimpleService_AnotherCall_Result should have at most one field: got %v fields", count)
	}

	return nil
}

// String returns a readable string representation of a SimpleService_AnotherCall_Result
// struct.
func (v *SimpleService_AnotherCall_Result) String() string {
	if v == nil {
		return "<nil>"
	}

	var fields [1]string
	i := 0
	if v.AuthErr != nil {
		fields[i] = fmt.Sprintf("AuthErr: %v", v.AuthErr)
		i++
	}

	return fmt.Sprintf("SimpleService_AnotherCall_Result{%v}", strings.Join(fields[:i], ", "))
}

// Equals returns true if all the fields of this SimpleService_AnotherCall_Result match the
// provided SimpleService_AnotherCall_Result.
//
// This function performs a deep comparison.
func (v *SimpleService_AnotherCall_Result) Equals(rhs *SimpleService_AnotherCall_Result) bool {
	if v == nil {
		return rhs == nil
	} else if rhs == nil {
		return false
	}
	if !((v.AuthErr == nil && rhs.AuthErr == nil) || (v.AuthErr != nil && rhs.AuthErr != nil && v.AuthErr.Equals(rhs.AuthErr))) {
		return false
	}

	return true
}

// MarshalLogObject implements zapcore.ObjectMarshaler, enabling
// fast logging of SimpleService_AnotherCall_Result.
func (v *SimpleService_AnotherCall_Result) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
	if v == nil {
		return nil
	}
	if v.AuthErr != nil {
		err = multierr.Append(err, enc.AddObject("authErr", v.AuthErr))
	}
	return err
}

// GetAuthErr returns the value of AuthErr if it is set or its
// zero value if it is unset.
func (v *SimpleService_AnotherCall_Result) GetAuthErr() (o *AuthErr) {
	if v != nil && v.AuthErr != nil {
		return v.AuthErr
	}

	return
}

// IsSetAuthErr returns true if AuthErr is not nil.
func (v *SimpleService_AnotherCall_Result) IsSetAuthErr() bool {
	return v != nil && v.AuthErr != nil
}

// MethodName returns the name of the Thrift function as specified in
// the IDL, for which this struct represent the result.
//
// This will always be "anotherCall" for this struct.
func (v *SimpleService_AnotherCall_Result) MethodName() string {
	return "anotherCall"
}

// EnvelopeType returns the kind of value inside this struct.
//
// This will always be Reply for this struct.
func (v *SimpleService_AnotherCall_Result) EnvelopeType() wire.EnvelopeType {
	return wire.Reply
}

// SimpleService_Call_Args represents the arguments for the SimpleService.call function.
//
// The arguments for call are sent and received over the wire as this struct.
type SimpleService_Call_Args struct {
	Arg         *BazRequest `json:"arg,required"`
	I64Optional *int64      `json:"i64Optional,omitempty"`
	TestUUID    *UUID       `json:"testUUID,omitempty"`
}

// ToWire translates a SimpleService_Call_Args struct into a Thrift-level intermediate
// representation. This intermediate representation may be serialized
// into bytes using a ThriftRW protocol implementation.
//
// An error is returned if the struct or any of its fields failed to
// validate.
//
//	x, err := v.ToWire()
//	if err != nil {
//	  return err
//	}
//
//	if err := binaryProtocol.Encode(x, writer); err != nil {
//	  return err
//	}
func (v *SimpleService_Call_Args) ToWire() (wire.Value, error) {
	var (
		fields [3]wire.Field
		i      int = 0
		w      wire.Value
		err    error
	)

	if v.Arg == nil {
		return w, errors.New("field Arg of SimpleService_Call_Args is required")
	}
	w, err = v.Arg.ToWire()
	if err != nil {
		return w, err
	}
	fields[i] = wire.Field{ID: 1, Value: w}
	i++
	if v.I64Optional != nil {
		w, err = wire.NewValueI64(*(v.I64Optional)), error(nil)
		if err != nil {
			return w, err
		}
		fields[i] = wire.Field{ID: 2, Value: w}
		i++
	}
	if v.TestUUID != nil {
		w, err = v.TestUUID.ToWire()
		if err != nil {
			return w, err
		}
		fields[i] = wire.Field{ID: 3, Value: w}
		i++
	}

	return wire.NewValueStruct(wire.Struct{Fields: fields[:i]}), nil
}

// FromWire deserializes a SimpleService_Call_Args struct from its Thrift-level
// representation. The Thrift-level representation may be obtained
// from a ThriftRW protocol implementation.
//
// An error is returned if we were unable to build a SimpleService_Call_Args struct
// from the provided intermediate representation.
//
//	x, err := binaryProtocol.Decode(reader, wire.TStruct)
//	if err != nil {
//	  return nil, err
//	}
//
//	var v SimpleService_Call_Args
//	if err := v.FromWire(x); err != nil {
//	  return nil, err
//	}
//	return &v, nil
func (v *SimpleService_Call_Args) FromWire(w wire.Value) error {
	var err error

	argIsSet := false

	for _, field := range w.GetStruct().Fields {
		switch field.ID {
		case 1:
			if field.Value.Type() == wire.TStruct {
				v.Arg, err = _BazRequest_Read(field.Value)
				if err != nil {
					return err
				}
				argIsSet = true
			}
		case 2:
			if field.Value.Type() == wire.TI64 {
				var x int64
				x, err = field.Value.GetI64(), error(nil)
				v.I64Optional = &x
				if err != nil {
					return err
				}

			}
		case 3:
			if field.Value.Type() == wire.TBinary {
				var x UUID
				x, err = _UUID_Read(field.Value)
				v.TestUUID = &x
				if err != nil {
					return err
				}

			}
		}
	}

	if !argIsSet {
		return errors.New("field Arg of SimpleService_Call_Args is required")
	}

	return nil
}

// Encode serializes a SimpleService_Call_Args struct directly into bytes, without going
// through an intermediary type.
//
// An error is returned if a SimpleService_Call_Args struct could not be encoded.
func (v *SimpleService_Call_Args) Encode(sw stream.Writer) error {
	if err := sw.WriteStructBegin(); err != nil {
		return err
	}

	if v.Arg == nil {
		return errors.New("field Arg of SimpleService_Call_Args is required")
	}
	if err := sw.WriteFieldBegin(stream.FieldHeader{ID: 1, Type: wire.TStruct}); err != nil {
		return err
	}
	if err := v.Arg.Encode(sw); err != nil {
		return err
	}
	if err := sw.WriteFieldEnd(); err != nil {
		return err
	}

	if v.I64Optional != nil {
		if err := sw.WriteFieldBegin(stream.FieldHeader{ID: 2, Type: wire.TI64}); err != nil {
			return err
		}
		if err := sw.WriteInt64(*(v.I64Optional)); err != nil {
			return err
		}
		if err := sw.WriteFieldEnd(); err != nil {
			return err
		}
	}

	if v.TestUUID != nil {
		if err := sw.WriteFieldBegin(stream.FieldHeader{ID: 3, Type: wire.TBinary}); err != nil {
			return err
		}
		if err := v.TestUUID.Encode(sw); err != nil {
			return err
		}
		if err := sw.WriteFieldEnd(); err != nil {
			return err
		}
	}

	return sw.WriteStructEnd()
}

// Decode deserializes a SimpleService_Call_Args struct directly from its Thrift-level
// representation, without going through an intemediary type.
//
// An error is returned if a SimpleService_Call_Args struct could not be generated from the wire
// representation.
func (v *SimpleService_Call_Args) Decode(sr stream.Reader) error {

	argIsSet := false

	if err := sr.ReadStructBegin(); err != nil {
		return err
	}

	fh, ok, err := sr.ReadFieldBegin()
	if err != nil {
		return err
	}

	for ok {
		switch {
		case fh.ID == 1 && fh.Type == wire.TStruct:
			v.Arg, err = _BazRequest_Decode(sr)
			if err != nil {
				return err
			}
			argIsSet = true
		case fh.ID == 2 && fh.Type == wire.TI64:
			var x int64
			x, err = sr.ReadInt64()
			v.I64Optional = &x
			if err != nil {
				return err
			}

		case fh.ID == 3 && fh.Type == wire.TBinary:
			var x UUID
			x, err = _UUID_Decode(sr)
			v.TestUUID = &x
			if err != nil {
				return err
			}

		default:
			if err := sr.Skip(fh.Type); err != nil {
				return err
			}
		}

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

		if fh, ok, err = sr.ReadFieldBegin(); err != nil {
			return err
		}
	}

	if err := sr.ReadStructEnd(); err != nil {
		return err
	}

	if !argIsSet {
		return errors.New("field Arg of SimpleService_Call_Args is required")
	}

	return nil
}

// String returns a readable string representation of a SimpleService_Call_Args
// struct.
func (v *SimpleService_Call_Args) String() string {
	if v == nil {
		return "<nil>"
	}

	var fields [3]string
	i := 0
	fields[i] = fmt.Sprintf("Arg: %v", v.Arg)
	i++
	if v.I64Optional != nil {
		fields[i] = fmt.Sprintf("I64Optional: %v", *(v.I64Optional))
		i++
	}
	if v.TestUUID != nil {
		fields[i] = fmt.Sprintf("TestUUID: %v", *(v.TestUUID))
		i++
	}

	return fmt.Sprintf("SimpleService_Call_Args{%v}", strings.Join(fields[:i], ", "))
}

// Equals returns true if all the fields of this SimpleService_Call_Args match the
// provided SimpleService_Call_Args.
//
// This function performs a deep comparison.
func (v *SimpleService_Call_Args) Equals(rhs *SimpleService_Call_Args) bool {
	if v == nil {
		return rhs == nil
	} else if rhs == nil {
		return false
	}
	if !v.Arg.Equals(rhs.Arg) {
		return false
	}
	if !_I64_EqualsPtr(v.I64Optional, rhs.I64Optional) {
		return false
	}
	if !_UUID_EqualsPtr(v.TestUUID, rhs.TestUUID) {
		return false
	}

	return true
}

// MarshalLogObject implements zapcore.ObjectMarshaler, enabling
// fast logging of SimpleService_Call_Args.
func (v *SimpleService_Call_Args) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
	if v == nil {
		return nil
	}
	err = multierr.Append(err, enc.AddObject("arg", v.Arg))
	if v.I64Optional != nil {
		enc.AddInt64("i64Optional", *v.I64Optional)
	}
	if v.TestUUID != nil {
		enc.AddString("testUUID", (string)(*v.TestUUID))
	}
	return err
}

// GetArg returns the value of Arg if it is set or its
// zero value if it is unset.
func (v *SimpleService_Call_Args) GetArg() (o *BazRequest) {
	if v != nil {
		o = v.Arg
	}
	return
}

// IsSetArg returns true if Arg is not nil.
func (v *SimpleService_Call_Args) IsSetArg() bool {
	return v != nil && v.Arg != nil
}

// GetI64Optional returns the value of I64Optional if it is set or its
// zero value if it is unset.
func (v *SimpleService_Call_Args) GetI64Optional() (o int64) {
	if v != nil && v.I64Optional != nil {
		return *v.I64Optional
	}

	return
}

// IsSetI64Optional returns true if I64Optional is not nil.
func (v *SimpleService_Call_Args) IsSetI64Optional() bool {
	return v != nil && v.I64Optional != nil
}

// GetTestUUID returns the value of TestUUID if it is set or its
// zero value if it is unset.
func (v *SimpleService_Call_Args) GetTestUUID() (o UUID) {
	if v != nil && v.TestUUID != nil {
		return *v.TestUUID
	}

	return
}

// IsSetTestUUID returns true if TestUUID is not nil.
func (v *SimpleService_Call_Args) IsSetTestUUID() bool {
	return v != nil && v.TestUUID != nil
}

// MethodName returns the name of the Thrift function as specified in
// the IDL, for which this struct represent the arguments.
//
// This will always be "call" for this struct.
func (v *SimpleService_Call_Args) MethodName() string {
	return "call"
}

// EnvelopeType returns the kind of value inside this struct.
//
// This will always be Call for this struct.
func (v *SimpleService_Call_Args) EnvelopeType() wire.EnvelopeType {
	return wire.Call
}

// SimpleService_Call_Helper provides functions that aid in handling the
// parameters and return values of the SimpleService.call
// function.
var SimpleService_Call_Helper = struct {
	// Args accepts the parameters of call in-order and returns
	// the arguments struct for the function.
	Args func(
		arg *BazRequest,
		i64Optional *int64,
		testUUID *UUID,
	) *SimpleService_Call_Args

	// IsException returns true if the given error can be thrown
	// by call.
	//
	// An error can be thrown by call only if the
	// corresponding exception type was mentioned in the 'throws'
	// section for it in the Thrift file.
	IsException func(error) bool

	// WrapResponse returns the result struct for call
	// given the error returned by it. The provided error may
	// be nil if call did not fail.
	//
	// This allows mapping errors returned by call into a
	// serializable result struct. WrapResponse returns a
	// non-nil error if the provided error cannot be thrown by
	// call
	//
	//   err := call(args)
	//   result, err := SimpleService_Call_Helper.WrapResponse(err)
	//   if err != nil {
	//     return fmt.Errorf("unexpected error from call: %v", err)
	//   }
	//   serialize(result)
	WrapResponse func(error) (*SimpleService_Call_Result, error)

	// UnwrapResponse takes the result struct for call
	// and returns the erorr returned by it (if any).
	//
	// The error is non-nil only if call threw an
	// exception.
	//
	//   result := deserialize(bytes)
	//   err := SimpleService_Call_Helper.UnwrapResponse(result)
	UnwrapResponse func(*SimpleService_Call_Result) error
}{}

func init() {
	SimpleService_Call_Helper.Args = func(
		arg *BazRequest,
		i64Optional *int64,
		testUUID *UUID,
	) *SimpleService_Call_Args {
		return &SimpleService_Call_Args{
			Arg:         arg,
			I64Optional: i64Optional,
			TestUUID:    testUUID,
		}
	}

	SimpleService_Call_Helper.IsException = func(err error) bool {
		switch err.(type) {
		case *AuthErr:
			return true
		default:
			return false
		}
	}

	SimpleService_Call_Helper.WrapResponse = func(err error) (*SimpleService_Call_Result, error) {
		if err == nil {
			return &SimpleService_Call_Result{}, nil
		}

		switch e := err.(type) {
		case *AuthErr:
			if e == nil {
				return nil, errors.New("WrapResponse received non-nil error type with nil value for SimpleService_Call_Result.AuthErr")
			}
			return &SimpleService_Call_Result{AuthErr: e}, nil
		}

		return nil, err
	}
	SimpleService_Call_Helper.UnwrapResponse = func(result *SimpleService_Call_Result) (err error) {
		if result.AuthErr != nil {
			err = result.AuthErr
			return
		}
		return
	}

}

// SimpleService_Call_Result represents the result of a SimpleService.call function call.
//
// The result of a call execution is sent and received over the wire as this struct.
type SimpleService_Call_Result struct {
	AuthErr *AuthErr `json:"authErr,omitempty"`
}

// ToWire translates a SimpleService_Call_Result struct into a Thrift-level intermediate
// representation. This intermediate representation may be serialized
// into bytes using a ThriftRW protocol implementation.
//
// An error is returned if the struct or any of its fields failed to
// validate.
//
//	x, err := v.ToWire()
//	if err != nil {
//	  return err
//	}
//
//	if err := binaryProtocol.Encode(x, writer); err != nil {
//	  return err
//	}
func (v *SimpleService_Call_Result) ToWire() (wire.Value, error) {
	var (
		fields [1]wire.Field
		i      int = 0
		w      wire.Value
		err    error
	)

	if v.AuthErr != nil {
		w, err = v.AuthErr.ToWire()
		if err != nil {
			return w, err
		}
		fields[i] = wire.Field{ID: 1, Value: w}
		i++
	}

	if i > 1 {
		return wire.Value{}, fmt.Errorf("SimpleService_Call_Result should have at most one field: got %v fields", i)
	}

	return wire.NewValueStruct(wire.Struct{Fields: fields[:i]}), nil
}

// FromWire deserializes a SimpleService_Call_Result struct from its Thrift-level
// representation. The Thrift-level representation may be obtained
// from a ThriftRW protocol implementation.
//
// An error is returned if we were unable to build a SimpleService_Call_Result struct
// from the provided intermediate representation.
//
//	x, err := binaryProtocol.Decode(reader, wire.TStruct)
//	if err != nil {
//	  return nil, err
//	}
//
//	var v SimpleService_Call_Result
//	if err := v.FromWire(x); err != nil {
//	  return nil, err
//	}
//	return &v, nil
func (v *SimpleService_Call_Result) FromWire(w wire.Value) error {
	var err error

	for _, field := range w.GetStruct().Fields {
		switch field.ID {
		case 1:
			if field.Value.Type() == wire.TStruct {
				v.AuthErr, err = _AuthErr_Read(field.Value)
				if err != nil {
					return err
				}

			}
		}
	}

	count := 0
	if v.AuthErr != nil {
		count++
	}
	if count > 1 {
		return fmt.Errorf("SimpleService_Call_Result should have at most one field: got %v fields", count)
	}

	return nil
}

// Encode serializes a SimpleService_Call_Result struct directly into bytes, without going
// through an intermediary type.
//
// An error is returned if a SimpleService_Call_Result struct could not be encoded.
func (v *SimpleService_Call_Result) Encode(sw stream.Writer) error {
	if err := sw.WriteStructBegin(); err != nil {
		return err
	}

	if v.AuthErr != nil {
		if err := sw.WriteFieldBegin(stream.FieldHeader{ID: 1, Type: wire.TStruct}); err != nil {
			return err
		}
		if err := v.AuthErr.Encode(sw); err != nil {
			return err
		}
		if err := sw.WriteFieldEnd(); err != nil {
			return err
		}
	}

	count := 0
	if v.AuthErr != nil {
		count++
	}

	if count > 1 {
		return fmt.Errorf("SimpleService_Call_Result should have at most one field: got %v fields", count)
	}

	return sw.WriteStructEnd()
}

// Decode deserializes a SimpleService_Call_Result struct directly from its Thrift-level
// representation, without going through an intemediary type.
//
// An error is returned if a SimpleService_Call_Result struct could not be generated from the wire
// representation.
func (v *SimpleService_Call_Result) Decode(sr stream.Reader) error {

	if err := sr.ReadStructBegin(); err != nil {
		return err
	}

	fh, ok, err := sr.ReadFieldBegin()
	if err != nil {
		return err
	}

	for ok {
		switch {
		case fh.ID == 1 && fh.Type == wire.TStruct:
			v.AuthErr, err = _AuthErr_Decode(sr)
			if err != nil {
				return err
			}

		default:
			if err := sr.Skip(fh.Type); err != nil {
				return err
			}
		}

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

		if fh, ok, err = sr.ReadFieldBegin(); err != nil {
			return err
		}
	}

	if err := sr.ReadStructEnd(); err != nil {
		return err
	}

	count := 0
	if v.AuthErr != nil {
		count++
	}
	if count > 1 {
		return fmt.Errorf("SimpleService_Call_Result should have at most one field: got %v fields", count)
	}

	return nil
}

// String returns a readable string representation of a SimpleService_Call_Result
// struct.
func (v *SimpleService_Call_Result) String() string {
	if v == nil {
		return "<nil>"
	}

	var fields [1]string
	i := 0
	if v.AuthErr != nil {
		fields[i] = fmt.Sprintf("AuthErr: %v", v.AuthErr)
		i++
	}

	return fmt.Sprintf("SimpleService_Call_Result{%v}", strings.Join(fields[:i], ", "))
}

// Equals returns true if all the fields of this SimpleService_Call_Result match the
// provided SimpleService_Call_Result.
//
// This function performs a deep comparison.
func (v *SimpleService_Call_Result) Equals(rhs *SimpleService_Call_Result) bool {
	if v == nil {
		return rhs == nil
	} else if rhs == nil {
		return false
	}
	if !((v.AuthErr == nil && rhs.AuthErr == nil) || (v.AuthErr != nil && rhs.AuthErr != nil && v.AuthErr.Equals(rhs.AuthErr))) {
		return false
	}

	return true
}

// MarshalLogObject implements zapcore.ObjectMarshaler, enabling
// fast logging of SimpleService_Call_Result.
func (v *SimpleService_Call_Result) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
	if v == nil {
		return nil
	}
	if v.AuthErr != nil {
		err = multierr.Append(err, enc.AddObject("authErr", v.AuthErr))
	}
	return err
}

// GetAuthErr returns the value of AuthErr if it is set or its
// zero value if it is unset.
func (v *SimpleService_Call_Result) GetAuthErr() (o *AuthErr) {
	if v != nil && v.AuthErr != nil {
		return v.AuthErr
	}

	return
}

// IsSetAuthErr returns true if AuthErr is not nil.
func (v *SimpleService_Call_Result) IsSetAuthErr() bool {
	return v != nil && v.AuthErr != nil
}

// MethodName returns the name of the Thrift function as specified in
// the IDL, for which this struct represent the result.
//
// This will always be "call" for this struct.
func (v *SimpleService_Call_Result) MethodName() string {
	return "call"
}

// EnvelopeType returns the kind of value inside this struct.
//
// This will always be Reply for this struct.
func (v *SimpleService_Call_Result) EnvelopeType() wire.EnvelopeType {
	return wire.Reply
}

// SimpleService_Compare_Args represents the arguments for the SimpleService.compare function.
//
// The arguments for compare are sent and received over the wire as this struct.
type SimpleService_Compare_Args struct {
	Arg1 *BazRequest `json:"arg1,required"`
	Arg2 *BazRequest `json:"arg2,required"`
}

// ToWire translates a SimpleService_Compare_Args struct into a Thrift-level intermediate
// representation. This intermediate representation may be serialized
// into bytes using a ThriftRW protocol implementation.
//
// An error is returned if the struct or any of its fields failed to
// validate.
//
//	x, err := v.ToWire()
//	if err != nil {
//	  return err
//	}
//
//	if err := binaryProtocol.Encode(x, writer); err != nil {
//	  return err
//	}
func (v *SimpleService_Compare_Args) ToWire() (wire.Value, error) {
	var (
		fields [2]wire.Field
		i      int = 0
		w      wire.Value
		err    error
	)

	if v.Arg1 == nil {
		return w, errors.New("field Arg1 of SimpleService_Compare_Args is required")
	}
	w, err = v.Arg1.ToWire()
	if err != nil {
		return w, err
	}
	fields[i] = wire.Field{ID: 1, Value: w}
	i++
	if v.Arg2 == nil {
		return w, errors.New("field Arg2 of SimpleService_Compare_Args is required")
	}
	w, err = v.Arg2.ToWire()
	if err != nil {
		return w, err
	}
	fields[i] = wire.Field{ID: 2, Value: w}
	i++

	return wire.NewValueStruct(wire.Struct{Fields: fields[:i]}), nil
}

// FromWire deserializes a SimpleService_Compare_Args struct from its Thrift-level
// representation. The Thrift-level representation may be obtained
// from a ThriftRW protocol implementation.
//
// An error is returned if we were unable to build a SimpleService_Compare_Args struct
// from the provided intermediate representation.
//
//	x, err := binaryProtocol.Decode(reader, wire.TStruct)
//	if err != nil {
//	  return nil, err
//	}
//
//	var v SimpleService_Compare_Args
//	if err := v.FromWire(x); err != nil {
//	  return nil, err
//	}
//	return &v, nil
func (v *SimpleService_Compare_Args) FromWire(w wire.Value) error {
	var err error

	arg1IsSet := false
	arg2IsSet := false

	for _, field := range w.GetStruct().Fields {
		switch field.ID {
		case 1:
			if field.Value.Type() == wire.TStruct {
				v.Arg1, err = _BazRequest_Read(field.Value)
				if err != nil {
					return err
				}
				arg1IsSet = true
			}
		case 2:
			if field.Value.Type() == wire.TStruct {
				v.Arg2, err = _BazRequest_Read(field.Value)
				if err != nil {
					return err
				}
				arg2IsSet = true
			}
		}
	}

	if !arg1IsSet {
		return errors.New("field Arg1 of SimpleService_Compare_Args is required")
	}

	if !arg2IsSet {
		return errors.New("field Arg2 of SimpleService_Compare_Args is required")
	}

	return nil
}

// Encode serializes a SimpleService_Compare_Args struct directly into bytes, without going
// through an intermediary type.
//
// An error is returned if a SimpleService_Compare_Args struct could not be encoded.
func (v *SimpleService_Compare_Args) Encode(sw stream.Writer) error {
	if err := sw.WriteStructBegin(); err != nil {
		return err
	}

	if v.Arg1 == nil {
		return errors.New("field Arg1 of SimpleService_Compare_Args is required")
	}
	if err := sw.WriteFieldBegin(stream.FieldHeader{ID: 1, Type: wire.TStruct}); err != nil {
		return err
	}
	if err := v.Arg1.Encode(sw); err != nil {
		return err
	}
	if err := sw.WriteFieldEnd(); err != nil {
		return err
	}

	if v.Arg2 == nil {
		return errors.New("field Arg2 of SimpleService_Compare_Args is required")
	}
	if err := sw.WriteFieldBegin(stream.FieldHeader{ID: 2, Type: wire.TStruct}); err != nil {
		return err
	}
	if err := v.Arg2.Encode(sw); err != nil {
		return err
	}
	if err := sw.WriteFieldEnd(); err != nil {
		return err
	}

	return sw.WriteStructEnd()
}

// Decode deserializes a SimpleService_Compare_Args struct directly from its Thrift-level
// representation, without going through an intemediary type.
//
// An error is returned if a SimpleService_Compare_Args struct could not be generated from the wire
// representation.
func (v *SimpleService_Compare_Args) Decode(sr stream.Reader) error {

	arg1IsSet := false
	arg2IsSet := false

	if err := sr.ReadStructBegin(); err != nil {
		return err
	}

	fh, ok, err := sr.ReadFieldBegin()
	if err != nil {
		return err
	}

	for ok {
		switch {
		case fh.ID == 1 && fh.Type == wire.TStruct:
			v.Arg1, err = _BazRequest_Decode(sr)
			if err != nil {
				return err
			}
			arg1IsSet = true
		case fh.ID == 2 && fh.Type == wire.TStruct:
			v.Arg2, err = _BazRequest_Decode(sr)
			if err != nil {
				return err
			}
			arg2IsSet = true
		default:
			if err := sr.Skip(fh.Type); err != nil {
				return err
			}
		}

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

		if fh, ok, err = sr.ReadFieldBegin(); err != nil {
			return err
		}
	}

	if err := sr.ReadStructEnd(); err != nil {
		return err
	}

	if !arg1IsSet {
		return errors.New("field Arg1 of SimpleService_Compare_Args is required")
	}

	if !arg2IsSet {
		return errors.New("field Arg2 of SimpleService_Compare_Args is required")
	}

	return nil
}

// String returns a readable string representation of a SimpleService_Compare_Args
// struct.
func (v *SimpleService_Compare_Args) String() string {
	if v == nil {
		return "<nil>"
	}

	var fields [2]string
	i := 0
	fields[i] = fmt.Sprintf("Arg1: %v", v.Arg1)
	i++
	fields[i] = fmt.Sprintf("Arg2: %v", v.Arg2)
	i++

	return fmt.Sprintf("SimpleService_Compare_Args{%v}", strings.Join(fields[:i], ", "))
}

// Equals returns true if all the fields of this SimpleService_Compare_Args match the
// provided SimpleService_Compare_Args.
//
// This function performs a deep comparison.
func (v *SimpleService_Compare_Args) Equals(rhs *SimpleService_Compare_Args) bool {
	if v == nil {
		return rhs == nil
	} else if rhs == nil {
		return false
	}
	if !v.Arg1.Equals(rhs.Arg1) {
		return false
	}
	if !v.Arg2.Equals(rhs.Arg2) {
		return false
	}

	return true
}

// MarshalLogObject implements zapcore.ObjectMarshaler, enabling
// fast logging of SimpleService_Compare_Args.
func (v *SimpleService_Compare_Args) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
	if v == nil {
		return nil
	}
	err = multierr.Append(err, enc.AddObject("arg1", v.Arg1))
	err = multierr.Append(err, enc.AddObject("arg2", v.Arg2))
	return err
}

// GetArg1 returns the value of Arg1 if it is set or its
// zero value if it is unset.
func (v *SimpleService_Compare_Args) GetArg1() (o *BazRequest) {
	if v != nil {
		o = v.Arg1
	}
	return
}

// IsSetArg1 returns true if Arg1 is not nil.
func (v *SimpleService_Compare_Args) IsSetArg1() bool {
	return v != nil && v.Arg1 != nil
}

// GetArg2 returns the value of Arg2 if it is set or its
// zero value if it is unset.
func (v *SimpleService_Compare_Args) GetArg2() (o *BazRequest) {
	if v != nil {
		o = v.Arg2
	}
	return
}

// IsSetArg2 returns true if Arg2 is not nil.
func (v *SimpleService_Compare_Args) IsSetArg2() bool {
	return v != nil && v.Arg2 != nil
}

// MethodName returns the name of the Thrift function as specified in
// the IDL, for which this struct represent the arguments.
//
// This will always be "compare" for this struct.
func (v *SimpleService_Compare_Args) MethodName() string {
	return "compare"
}

// EnvelopeType returns the kind of value inside this struct.
//
// This will always be Call for this struct.
func (v *SimpleService_Compare_Args) EnvelopeType() wire.EnvelopeType {
	return wire.Call
}

// SimpleService_Compare_Helper provides functions that aid in handling the
// parameters and return values of the SimpleService.compare
// function.
var SimpleService_Compare_Helper = struct {
	// Args accepts the parameters of compare in-order and returns
	// the arguments struct for the function.
	Args func(
		arg1 *BazRequest,
		arg2 *BazRequest,
	) *SimpleService_Compare_Args

	// IsException returns true if the given error can be thrown
	// by compare.
	//
	// An error can be thrown by compare only if the
	// corresponding exception type was mentioned in the 'throws'
	// section for it in the Thrift file.
	IsException func(error) bool

	// WrapResponse returns the result struct for compare
	// given its return value and error.
	//
	// This allows mapping values and errors returned by
	// compare into a serializable result struct.
	// WrapResponse returns a non-nil error if the provided
	// error cannot be thrown by compare
	//
	//   value, err := compare(args)
	//   result, err := SimpleService_Compare_Helper.WrapResponse(value, err)
	//   if err != nil {
	//     return fmt.Errorf("unexpected error from compare: %v", err)
	//   }
	//   serialize(result)
	WrapResponse func(*BazResponse, error) (*SimpleService_Compare_Result, error)

	// UnwrapResponse takes the result struct for compare
	// and returns the value or error returned by it.
	//
	// The error is non-nil only if compare threw an
	// exception.
	//
	//   result := deserialize(bytes)
	//   value, err := SimpleService_Compare_Helper.UnwrapResponse(result)
	UnwrapResponse func(*SimpleService_Compare_Result) (*BazResponse, error)
}{}

func init() {
	SimpleService_Compare_Helper.Args = func(
		arg1 *BazRequest,
		arg2 *BazRequest,
	) *SimpleService_Compare_Args {
		return &SimpleService_Compare_Args{
			Arg1: arg1,
			Arg2: arg2,
		}
	}

	SimpleService_Compare_Helper.IsException = func(err error) bool {
		switch err.(type) {
		case *AuthErr:
			return true
		case *OtherAuthErr:
			return true
		default:
			return false
		}
	}

	SimpleService_Compare_Helper.WrapResponse = func(success *BazResponse, err error) (*SimpleService_Compare_Result, error) {
		if err == nil {
			return &SimpleService_Compare_Result{Success: success}, nil
		}

		switch e := err.(type) {
		case *AuthErr:
			if e == nil {
				return nil, errors.New("WrapResponse received non-nil error type with nil value for SimpleService_Compare_Result.AuthErr")
			}
			return &SimpleService_Compare_Result{AuthErr: e}, nil
		case *OtherAuthErr:
			if e == nil {
				return nil, errors.New("WrapResponse received non-nil error type with nil value for SimpleService_Compare_Result.OtherAuthErr")
			}
			return &SimpleService_Compare_Result{OtherAuthErr: e}, nil
		}

		return nil, err
	}
	SimpleService_Compare_Helper.UnwrapResponse = func(result *SimpleService_Compare_Result) (success *BazResponse, err error) {
		if result.AuthErr != nil {
			err = result.AuthErr
			return
		}
		if result.OtherAuthErr != nil {
			err = result.OtherAuthErr
			return
		}

		if result.Success != nil {
			success = result.Success
			return
		}

		err = errors.New("expected a non-void result")
		return
	}

}

// SimpleService_Compare_Result represents the result of a SimpleService.compare function call.
//
// The result of a compare execution is sent and received over the wire as this struct.
//
// Success is set only if the function did not throw an exception.
type SimpleService_Compare_Result struct {
	// Value returned by compare after a successful execution.
	Success      *BazResponse  `json:"success,omitempty"`
	AuthErr      *AuthErr      `json:"authErr,omitempty"`
	OtherAuthErr *OtherAuthErr `json:"otherAuthErr,omitempty"`
}

// ToWire translates a SimpleService_Compare_Result struct into a Thrift-level intermediate
// representation. This intermediate representation may be serialized
// into bytes using a ThriftRW protocol implementation.
//
// An error is returned if the struct or any of its fields failed to
// validate.
//
//	x, err := v.ToWire()
//	if err != nil {
//	  return err
//	}
//
//	if err := binaryProtocol.Encode(x, writer); err != nil {
//	  return err
//	}
func (v *SimpleService_Compare_Result) ToWire() (wire.Value, error) {
	var (
		fields [3]wire.Field
		i      int = 0
		w      wire.Value
		err    error
	)

	if v.Success != nil {
		w, err = v.Success.ToWire()
		if err != nil {
			return w, err
		}
		fields[i] = wire.Field{ID: 0, Value: w}
		i++
	}
	if v.AuthErr != nil {
		w, err = v.AuthErr.ToWire()
		if err != nil {
			return w, err
		}
		fields[i] = wire.Field{ID: 1, Value: w}
		i++
	}
	if v.OtherAuthErr != nil {
		w, err = v.OtherAuthErr.ToWire()
		if err != nil {
			return w, err
		}
		fields[i] = wire.Field{ID: 2, Value: w}
		i++
	}

	if i != 1 {
		return wire.Value{}, fmt.Errorf("SimpleService_Compare_Result should have exactly one field: got %v fields", i)
	}

	return wire.NewValueStruct(wire.Struct{Fields: fields[:i]}), nil
}

func _BazResponse_Read(w wire.Value) (*BazResponse, error) {
	var v BazResponse
	err := v.FromWire(w)
	return &v, err
}

func _OtherAuthErr_Read(w wire.Value) (*OtherAuthErr, error) {
	var v OtherAuthErr
	err := v.FromWire(w)
	return &v, err
}

// FromWire deserializes a SimpleService_Compare_Result struct from its Thrift-level
// representation. The Thrift-level representation may be obtained
// from a ThriftRW protocol implementation.
//
// An error is returned if we were unable to build a SimpleService_Compare_Result struct
// from the provided intermediate representation.
//
//	x, err := binaryProtocol.Decode(reader, wire.TStruct)
//	if err != nil {
//	  return nil, err
//	}
//
//	var v SimpleService_Compare_Result
//	if err := v.FromWire(x); err != nil {
//	  return nil, err
//	}
//	return &v, nil
func (v *SimpleService_Compare_Result) FromWire(w wire.Value) error {
	var err error

	for _, field := range w.GetStruct().Fields {
		switch field.ID {
		case 0:
			if field.Value.Type() == wire.TStruct {
				v.Success, err = _BazResponse_Read(field.Value)
				if err != nil {
					return err
				}

			}
		case 1:
			if field.Value.Type() == wire.TStruct {
				v.AuthErr, err = _AuthErr_Read(field.Value)
				if err != nil {
					return err
				}

			}
		case 2:
			if field.Value.Type() == wire.TStruct {
				v.OtherAuthErr, err = _OtherAuthErr_Read(field.Value)
				if err != nil {
					return err
				}

			}
		}
	}

	count := 0
	if v.Success != nil {
		count++
	}
	if v.AuthErr != nil {
		count++
	}
	if v.OtherAuthErr != nil {
		count++
	}
	if count != 1 {
		return fmt.Errorf("SimpleService_Compare_Result should have exactly one field: got %v fields", count)
	}

	return nil
}

// Encode serializes a SimpleService_Compare_Result struct directly into bytes, without going
// through an intermediary type.
//
// An error is returned if a SimpleService_Compare_Result struct could not be encoded.
func (v *SimpleService_Compare_Result) Encode(sw stream.Writer) error {
	if err := sw.WriteStructBegin(); err != nil {
		return err
	}

	if v.Success != nil {
		if err := sw.WriteFieldBegin(stream.FieldHeader{ID: 0, Type: wire.TStruct}); err != nil {
			return err
		}
		if err := v.Success.Encode(sw); err != nil {
			return err
		}
		if err := sw.WriteFieldEnd(); err != nil {
			return err
		}
	}

	if v.AuthErr != nil {
		if err := sw.WriteFieldBegin(stream.FieldHeader{ID: 1, Type: wire.TStruct}); err != nil {
			return err
		}
		if err := v.AuthErr.Encode(sw); err != nil {
			return err
		}
		if err := sw.WriteFieldEnd(); err != nil {
			return err
		}
	}

	if v.OtherAuthErr != nil {
		if err := sw.WriteFieldBegin(stream.FieldHeader{ID: 2, Type: wire.TStruct}); err != nil {
			return err
		}
		if err := v.OtherAuthErr.Encode(sw); err != nil {
			return err
		}
		if err := sw.WriteFieldEnd(); err != nil {
			return err
		}
	}

	count := 0
	if v.Success != nil {
		count++
	}
	if v.AuthErr != nil {
		count++
	}
	if v.OtherAuthErr != nil {
		count++
	}

	if count != 1 {
		return fmt.Errorf("SimpleService_Compare_Result should have exactly one field: got %v fields", count)
	}

	return sw.WriteStructEnd()
}

func _BazResponse_Decode(sr stream.Reader) (*BazResponse, error) {
	var v BazResponse
	err := v.Decode(sr)
	return &v, err
}

func _OtherAuthErr_Decode(sr stream.Reader) (*OtherAuthErr, error) {
	var v OtherAuthErr
	err := v.Decode(sr)
	return &v, err
}

// Decode deserializes a SimpleService_Compare_Result struct directly from its Thrift-level
// representation, without going through an intemediary type.
//
// An error is returned if a SimpleService_Compare_Result struct could not be generated from the wire
// representation.
func (v *SimpleService_Compare_Result) Decode(sr stream.Reader) error {

	if err := sr.ReadStructBegin(); err != nil {
		return err
	}

	fh, ok, err := sr.ReadFieldBegin()
	if err != nil {
		return err
	}

	for ok {
		switch {
		case fh.ID == 0 && fh.Type == wire.TStruct:
			v.Success, err = _BazResponse_Decode(sr)
			if err != nil {
				return err
			}

		case fh.ID == 1 && fh.Type == wire.TStruct:
			v.AuthErr, err = _AuthErr_Decode(sr)
			if err != nil {
				return err
			}

		case fh.ID == 2 && fh.Type == wire.TStruct:
			v.OtherAuthErr, err = _OtherAuthErr_Decode(sr)
			if err != nil {
				return err
			}

		default:
			if err := sr.Skip(fh.Type); err != nil {
				return err
			}
		}

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

		if fh, ok, err = sr.ReadFieldBegin(); err != nil {
			return err
		}
	}

	if err := sr.ReadStructEnd(); err != nil {
		return err
	}

	count := 0
	if v.Success != nil {
		count++
	}
	if v.AuthErr != nil {
		count++
	}
	if v.OtherAuthErr != nil {
		count++
	}
	if count != 1 {
		return fmt.Errorf("SimpleService_Compare_Result should have exactly one field: got %v fields", count)
	}

	return nil
}

// String returns a readable string representation of a SimpleService_Compare_Result
// struct.
func (v *SimpleService_Compare_Result) String() string {
	if v == nil {
		return "<nil>"
	}

	var fields [3]string
	i := 0
	if v.Success != nil {
		fields[i] = fmt.Sprintf("Success: %v", v.Success)
		i++
	}
	if v.AuthErr != nil {
		fields[i] = fmt.Sprintf("AuthErr: %v", v.AuthErr)
		i++
	}
	if v.OtherAuthErr != nil {
		fields[i] = fmt.Sprintf("OtherAuthErr: %v", v.OtherAuthErr)
		i++
	}

	return fmt.Sprintf("SimpleService_Compare_Result{%v}", strings.Join(fields[:i], ", "))
}

// Equals returns true if all the fields of this SimpleService_Compare_Result match the
// provided SimpleService_Compare_Result.
//
// This function performs a deep comparison.
func (v *SimpleService_Compare_Result) Equals(rhs *SimpleService_Compare_Result) bool {
	if v == nil {
		return rhs == nil
	} else if rhs == nil {
		return false
	}
	if !((v.Success == nil && rhs.Success == nil) || (v.Success != nil && rhs.Success != nil && v.Success.Equals(rhs.Success))) {
		return false
	}
	if !((v.AuthErr == nil && rhs.AuthErr == nil) || (v.AuthErr != nil && rhs.AuthErr != nil && v.AuthErr.Equals(rhs.AuthErr))) {
		return false
	}
	if !((v.OtherAuthErr == nil && rhs.OtherAuthErr == nil) || (v.OtherAuthErr != nil && rhs.OtherAuthErr != nil && v.OtherAuthErr.Equals(rhs.OtherAuthErr))) {
		return false
	}

	return true
}

// MarshalLogObject implements zapcore.ObjectMarshaler, enabling
// fast logging of SimpleService_Compare_Result.
func (v *SimpleService_Compare_Result) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
	if v == nil {
		return nil
	}
	if v.Success != nil {
		err = multierr.Append(err, enc.AddObject("success", v.Success))
	}
	if v.AuthErr != nil {
		err = multierr.Append(err, enc.AddObject("authErr", v.AuthErr))
	}
	if v.OtherAuthErr != nil {
		err = multierr.Append(err, enc.AddObject("otherAuthErr", v.OtherAuthErr))
	}
	return err
}

// GetSuccess returns the value of Success if it is set or its
// zero value if it is unset.
func (v *SimpleService_Compare_Result) GetSuccess() (o *BazResponse) {
	if v != nil && v.Success != nil {
		return v.Success
	}

	return
}

// IsSetSuccess returns true if Success is not nil.
func (v *SimpleService_Compare_Result) IsSetSuccess() bool {
	return v != nil && v.Success != nil
}

// GetAuthErr returns the value of AuthErr if it is set or its
// zero value if it is unset.
func (v *SimpleService_Compare_Result) GetAuthErr() (o *AuthErr) {
	if v != nil && v.AuthErr != nil {
		return v.AuthErr
	}

	return
}

// IsSetAuthErr returns true if AuthErr is not nil.
func (v *SimpleService_Compare_Result) IsSetAuthErr() bool {
	return v != nil && v.AuthErr != nil
}

// GetOtherAuthErr returns the value of OtherAuthErr if it is set or its
// zero value if it is unset.
func (v *SimpleService_Compare_Result) GetOtherAuthErr() (o *OtherAuthErr) {
	if v != nil && v.OtherAuthErr != nil {
		return v.OtherAuthErr
	}

	return
}

// IsSetOtherAuthErr returns true if OtherAuthErr is not nil.
func (v *SimpleService_Compare_Result) IsSetOtherAuthErr() bool {
	return v != nil && v.OtherAuthErr != nil
}

// MethodName returns the name of the Thrift function as specified in
// the IDL, for which this struct represent the result.
//
// This will always be "compare" for this struct.
func (v *SimpleService_Compare_Result) MethodName() string {
	return "compare"
}

// EnvelopeType returns the kind of value inside this struct.
//
// This will always be Reply for this struct.
func (v *SimpleService_Compare_Result) EnvelopeType() wire.EnvelopeType {
	return wire.Reply
}

// SimpleService_GetProfile_Args represents the arguments for the SimpleService.getProfile function.
//
// The arguments for getProfile are sent and received over the wire as this struct.
type SimpleService_GetProfile_Args struct {
	Request *GetProfileRequest `json:"request,required"`
}

// ToWire translates a SimpleService_GetProfile_Args struct into a Thrift-level intermediate
// representation. This intermediate representation may be serialized
// into bytes using a ThriftRW protocol implementation.
//
// An error is returned if the struct or any of its fields failed to
// validate.
//
//	x, err := v.ToWire()
//	if err != nil {
//	  return err
//	}
//
//	if err := binaryProtocol.Encode(x, writer); err != nil {
//	  return err
//	}
func (v *SimpleService_GetProfile_Args) ToWire() (wire.Value, error) {
	var (
		fields [1]wire.Field
		i      int = 0
		w      wire.Value
		err    error
	)

	if v.Request == nil {
		return w, errors.New("field Request of SimpleService_GetProfile_Args is required")
	}
	w, err = v.Request.ToWire()
	if err != nil {
		return w, err
	}
	fields[i] = wire.Field{ID: 1, Value: w}
	i++

	return wire.NewValueStruct(wire.Struct{Fields: fields[:i]}), nil
}

func _GetProfileRequest_Read(w wire.Value) (*GetProfileRequest, error) {
	var v GetProfileRequest
	err := v.FromWire(w)
	return &v, err
}

// FromWire deserializes a SimpleService_GetProfile_Args struct from its Thrift-level
// representation. The Thrift-level representation may be obtained
// from a ThriftRW protocol implementation.
//
// An error is returned if we were unable to build a SimpleService_GetProfile_Args struct
// from the provided intermediate representation.
//
//	x, err := binaryProtocol.Decode(reader, wire.TStruct)
//	if err != nil {
//	  return nil, err
//	}
//
//	var v SimpleService_GetProfile_Args
//	if err := v.FromWire(x); err != nil {
//	  return nil, err
//	}
//	return &v, nil
func (v *SimpleService_GetProfile_Args) FromWire(w wire.Value) error {
	var err error

	requestIsSet := false

	for _, field := range w.GetStruct().Fields {
		switch field.ID {
		case 1:
			if field.Value.Type() == wire.TStruct {
				v.Request, err = _GetProfileRequest_Read(field.Value)
				if err != nil {
					return err
				}
				requestIsSet = true
			}
		}
	}

	if !requestIsSet {
		return errors.New("field Request of SimpleService_GetProfile_Args is required")
	}

	return nil
}

// Encode serializes a SimpleService_GetProfile_Args struct directly into bytes, without going
// through an intermediary type.
//
// An error is returned if a SimpleService_GetProfile_Args struct could not be encoded.
func (v *SimpleService_GetProfile_Args) Encode(sw stream.Writer) error {
	if err := sw.WriteStructBegin(); err != nil {
		return err
	}

	if v.Request == nil {
		return errors.New("field Request of SimpleService_GetProfile_Args is required")
	}
	if err := sw.WriteFieldBegin(stream.FieldHeader{ID: 1, Type: wire.TStruct}); err != nil {
		return err
	}
	if err := v.Request.Encode(sw); err != nil {
		return err
	}
	if err := sw.WriteFieldEnd(); err != nil {
		return err
	}

	return sw.WriteStructEnd()
}

func _GetProfileRequest_Decode(sr stream.Reader) (*GetProfileRequest, error) {
	var v GetProfileRequest
	err := v.Decode(sr)
	return &v, err
}

// Decode deserializes a SimpleService_GetProfile_Args struct directly from its Thrift-level
// representation, without going through an intemediary type.
//
// An error is returned if a SimpleService_GetProfile_Args struct could not be generated from the wire
// representation.
func (v *SimpleService_GetProfile_Args) Decode(sr stream.Reader) error {

	requestIsSet := false

	if err := sr.ReadStructBegin(); err != nil {
		return err
	}

	fh, ok, err := sr.ReadFieldBegin()
	if err != nil {
		return err
	}

	for ok {
		switch {
		case fh.ID == 1 && fh.Type == wire.TStruct:
			v.Request, err = _GetProfileRequest_Decode(sr)
			if err != nil {
				return err
			}
			requestIsSet = true
		default:
			if err := sr.Skip(fh.Type); err != nil {
				return err
			}
		}

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

		if fh, ok, err = sr.ReadFieldBegin(); err != nil {
			return err
		}
	}

	if err := sr.ReadStructEnd(); err != nil {
		return err
	}

	if !requestIsSet {
		return errors.New("field Request of SimpleService_GetProfile_Args is required")
	}

	return nil
}

// String returns a readable string representation of a SimpleService_GetProfile_Args
// struct.
func (v *SimpleService_GetProfile_Args) String() string {
	if v == nil {
		return "<nil>"
	}

	var fields [1]string
	i := 0
	fields[i] = fmt.Sprintf("Request: %v", v.Request)
	i++

	return fmt.Sprintf("SimpleService_GetProfile_Args{%v}", strings.Join(fields[:i], ", "))
}

// Equals returns true if all the fields of this SimpleService_GetProfile_Args match the
// provided SimpleService_GetProfile_Args.
//
// This function performs a deep comparison.
func (v *SimpleService_GetProfile_Args) Equals(rhs *SimpleService_GetProfile_Args) bool {
	if v == nil {
		return rhs == nil
	} else if rhs == nil {
		return false
	}
	if !v.Request.Equals(rhs.Request) {
		return false
	}

	return true
}

// MarshalLogObject implements zapcore.ObjectMarshaler, enabling
// fast logging of SimpleService_GetProfile_Args.
func (v *SimpleService_GetProfile_Args) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
	if v == nil {
		return nil
	}
	err = multierr.Append(err, enc.AddObject("request", v.Request))
	return err
}

// GetRequest returns the value of Request if it is set or its
// zero value if it is unset.
func (v *SimpleService_GetProfile_Args) GetRequest() (o *GetProfileRequest) {
	if v != nil {
		o = v.Request
	}
	return
}

// IsSetRequest returns true if Request is not nil.
func (v *SimpleService_GetProfile_Args) IsSetRequest() bool {
	return v != nil && v.Request != nil
}

// MethodName returns the name of the Thrift function as specified in
// the IDL, for which this struct represent the arguments.
//
// This will always be "getProfile" for this struct.
func (v *SimpleService_GetProfile_Args) MethodName() string {
	return "getProfile"
}

// EnvelopeType returns the kind of value inside this struct.
//
// This will always be Call for this struct.
func (v *SimpleService_GetProfile_Args) EnvelopeType() wire.EnvelopeType {
	return wire.Call
}

// SimpleService_GetProfile_Helper provides functions that aid in handling the
// parameters and return values of the SimpleService.getProfile
// function.
var SimpleService_GetProfile_Helper = struct {
	// Args accepts the parameters of getProfile in-order and returns
	// the arguments struct for the function.
	Args func(
		request *GetProfileRequest,
	) *SimpleService_GetProfile_Args

	// IsException returns true if the given error can be thrown
	// by getProfile.
	//
	// An error can be thrown by getProfile only if the
	// corresponding exception type was mentioned in the 'throws'
	// section for it in the Thrift file.
	IsException func(error) bool

	// WrapResponse returns the result struct for getProfile
	// given its return value and error.
	//
	// This allows mapping values and errors returned by
	// getProfile into a serializable result struct.
	// WrapResponse returns a non-nil error if the provided
	// error cannot be thrown by getProfile
	//
	//   value, err := getProfile(args)
	//   result, err := SimpleService_GetProfile_Helper.WrapResponse(value, err)
	//   if err != nil {
	//     return fmt.Errorf("unexpected error from getProfile: %v", err)
	//   }
	//   serialize(result)
	WrapResponse func(*GetProfileResponse, error) (*SimpleService_GetProfile_Result, error)

	// UnwrapResponse takes the result struct for getProfile
	// and returns the value or error returned by it.
	//
	// The error is non-nil only if getProfile threw an
	// exception.
	//
	//   result := deserialize(bytes)
	//   value, err := SimpleService_GetProfile_Helper.UnwrapResponse(result)
	UnwrapResponse func(*SimpleService_GetProfile_Result) (*GetProfileResponse, error)
}{}

func init() {
	SimpleService_GetProfile_Helper.Args = func(
		request *GetProfileRequest,
	) *SimpleService_GetProfile_Args {
		return &SimpleService_GetProfile_Args{
			Request: request,
		}
	}

	SimpleService_GetProfile_Helper.IsException = func(err error) bool {
		switch err.(type) {
		case *AuthErr:
			return true
		default:
			return false
		}
	}

	SimpleService_GetProfile_Helper.WrapResponse = func(success *GetProfileResponse, err error) (*SimpleService_GetProfile_Result, error) {
		if err == nil {
			return &SimpleService_GetProfile_Result{Success: success}, nil
		}

		switch e := err.(type) {
		case *AuthErr:
			if e == nil {
				return nil, errors.New("WrapResponse received non-nil error type with nil value for SimpleService_GetProfile_Result.AuthErr")
			}
			return &SimpleService_GetProfile_Result{AuthErr: e}, nil
		}

		return nil, err
	}
	SimpleService_GetProfile_Helper.UnwrapResponse = func(result *SimpleService_GetProfile_Result) (success *GetProfileResponse, err error) {
		if result.AuthErr != nil {
			err = result.AuthErr
			return
		}

		if result.Success != nil {
			success = result.Success
			return
		}

		err = errors.New("expected a non-void result")
		return
	}

}

// SimpleService_GetProfile_Result represents the result of a SimpleService.getProfile function call.
//
// The result of a getProfile execution is sent and received over the wire as this struct.
//
// Success is set only if the function did not throw an exception.
type SimpleService_GetProfile_Result struct {
	// Value returned by getProfile after a successful execution.
	Success *GetProfileResponse `json:"success,omitempty"`
	AuthErr *AuthErr            `json:"authErr,omitempty"`
}

// ToWire translates a SimpleService_GetProfile_Result struct into a Thrift-level intermediate
// representation. This intermediate representation may be serialized
// into bytes using a ThriftRW protocol implementation.
//
// An error is returned if the struct or any of its fields failed to
// validate.
//
//	x, err := v.ToWire()
//	if err != nil {
//	  return err
//	}
//
//	if err := binaryProtocol.Encode(x, writer); err != nil {
//	  return err
//	}
func (v *SimpleService_GetProfile_Result) ToWire() (wire.Value, error) {
	var (
		fields [2]wire.Field
		i      int = 0
		w      wire.Value
		err    error
	)

	if v.Success != nil {
		w, err = v.Success.ToWire()
		if err != nil {
			return w, err
		}
		fields[i] = wire.Field{ID: 0, Value: w}
		i++
	}
	if v.AuthErr != nil {
		w, err = v.AuthErr.ToWire()
		if err != nil {
			return w, err
		}
		fields[i] = wire.Field{ID: 1, Value: w}
		i++
	}

	if i != 1 {
		return wire.Value{}, fmt.Errorf("SimpleService_GetProfile_Result should have exactly one field: got %v fields", i)
	}

	return wire.NewValueStruct(wire.Struct{Fields: fields[:i]}), nil
}

func _GetProfileResponse_Read(w wire.Value) (*GetProfileResponse, error) {
	var v GetProfileResponse
	err := v.FromWire(w)
	return &v, err
}

// FromWire deserializes a SimpleService_GetProfile_Result struct from its Thrift-level
// representation. The Thrift-level representation may be obtained
// from a ThriftRW protocol implementation.
//
// An error is returned if we were unable to build a SimpleService_GetProfile_Result struct
// from the provided intermediate representation.
//
//	x, err := binaryProtocol.Decode(reader, wire.TStruct)
//	if err != nil {
//	  return nil, err
//	}
//
//	var v SimpleService_GetProfile_Result
//	if err := v.FromWire(x); err != nil {
//	  return nil, err
//	}
//	return &v, nil
func (v *SimpleService_GetProfile_Result) FromWire(w wire.Value) error {
	var err error

	for _, field := range w.GetStruct().Fields {
		switch field.ID {
		case 0:
			if field.Value.Type() == wire.TStruct {
				v.Success, err = _GetProfileResponse_Read(field.Value)
				if err != nil {
					return err
				}

			}
		case 1:
			if field.Value.Type() == wire.TStruct {
				v.AuthErr, err = _AuthErr_Read(field.Value)
				if err != nil {
					return err
				}

			}
		}
	}

	count := 0
	if v.Success != nil {
		count++
	}
	if v.AuthErr != nil {
		count++
	}
	if count != 1 {
		return fmt.Errorf("SimpleService_GetProfile_Result should have exactly one field: got %v fields", count)
	}

	return nil
}

// Encode serializes a SimpleService_GetProfile_Result struct directly into bytes, without going
// through an intermediary type.
//
// An error is returned if a SimpleService_GetProfile_Result struct could not be encoded.
func (v *SimpleService_GetProfile_Result) Encode(sw stream.Writer) error {
	if err := sw.WriteStructBegin(); err != nil {
		return err
	}

	if v.Success != nil {
		if err := sw.WriteFieldBegin(stream.FieldHeader{ID: 0, Type: wire.TStruct}); err != nil {
			return err
		}
		if err := v.Success.Encode(sw); err != nil {
			return err
		}
		if err := sw.WriteFieldEnd(); err != nil {
			return err
		}
	}

	if v.AuthErr != nil {
		if err := sw.WriteFieldBegin(stream.FieldHeader{ID: 1, Type: wire.TStruct}); err != nil {
			return err
		}
		if err := v.AuthErr.Encode(sw); err != nil {
			return err
		}
		if err := sw.WriteFieldEnd(); err != nil {
			return err
		}
	}

	count := 0
	if v.Success != nil {
		count++
	}
	if v.AuthErr != nil {
		count++
	}

	if count != 1 {
		return fmt.Errorf("SimpleService_GetProfile_Result should have exactly one field: got %v fields", count)
	}

	return sw.WriteStructEnd()
}

func _GetProfileResponse_Decode(sr stream.Reader) (*GetProfileResponse, error) {
	var v GetProfileResponse
	err := v.Decode(sr)
	return &v, err
}

// Decode deserializes a SimpleService_GetProfile_Result struct directly from its Thrift-level
// representation, without going through an intemediary type.
//
// An error is returned if a SimpleService_GetProfile_Result struct could not be generated from the wire
// representation.
func (v *SimpleService_GetProfile_Result) Decode(sr stream.Reader) error {

	if err := sr.ReadStructBegin(); err != nil {
		return err
	}

	fh, ok, err := sr.ReadFieldBegin()
	if err != nil {
		return err
	}

	for ok {
		switch {
		case fh.ID == 0 && fh.Type == wire.TStruct:
			v.Success, err = _GetProfileResponse_Decode(sr)
			if err != nil {
				return err
			}

		case fh.ID == 1 && fh.Type == wire.TStruct:
			v.AuthErr, err = _AuthErr_Decode(sr)
			if err != nil {
				return err
			}

		default:
			if err := sr.Skip(fh.Type); err != nil {
				return err
			}
		}

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

		if fh, ok, err = sr.ReadFieldBegin(); err != nil {
			return err
		}
	}

	if err := sr.ReadStructEnd(); err != nil {
		return err
	}

	count := 0
	if v.Success != nil {
		count++
	}
	if v.AuthErr != nil {
		count++
	}
	if count != 1 {
		return fmt.Errorf("SimpleService_GetProfile_Result should have exactly one field: got %v fields", count)
	}

	return nil
}

// String returns a readable string representation of a SimpleService_GetProfile_Result
// struct.
func (v *SimpleService_GetProfile_Result) String() string {
	if v == nil {
		return "<nil>"
	}

	var fields [2]string
	i := 0
	if v.Success != nil {
		fields[i] = fmt.Sprintf("Success: %v", v.Success)
		i++
	}
	if v.AuthErr != nil {
		fields[i] = fmt.Sprintf("AuthErr: %v", v.AuthErr)
		i++
	}

	return fmt.Sprintf("SimpleService_GetProfile_Result{%v}", strings.Join(fields[:i], ", "))
}

// Equals returns true if all the fields of this SimpleService_GetProfile_Result match the
// provided SimpleService_GetProfile_Result.
//
// This function performs a deep comparison.
func (v *SimpleService_GetProfile_Result) Equals(rhs *SimpleService_GetProfile_Result) bool {
	if v == nil {
		return rhs == nil
	} else if rhs == nil {
		return false
	}
	if !((v.Success == nil && rhs.Success == nil) || (v.Success != nil && rhs.Success != nil && v.Success.Equals(rhs.Success))) {
		return false
	}
	if !((v.AuthErr == nil && rhs.AuthErr == nil) || (v.AuthErr != nil && rhs.AuthErr != nil && v.AuthErr.Equals(rhs.AuthErr))) {
		return false
	}

	return true
}

// MarshalLogObject implements zapcore.ObjectMarshaler, enabling
// fast logging of SimpleService_GetProfile_Result.
func (v *SimpleService_GetProfile_Result) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
	if v == nil {
		return nil
	}
	if v.Success != nil {
		err = multierr.Append(err, enc.AddObject("success", v.Success))
	}
	if v.AuthErr != nil {
		err = multierr.Append(err, enc.AddObject("authErr", v.AuthErr))
	}
	return err
}

// GetSuccess returns the value of Success if it is set or its
// zero value if it is unset.
func (v *SimpleService_GetProfile_Result) GetSuccess() (o *GetProfileResponse) {
	if v != nil && v.Success != nil {
		return v.Success
	}

	return
}

// IsSetSuccess returns true if Success is not nil.
func (v *SimpleService_GetProfile_Result) IsSetSuccess() bool {
	return v != nil && v.Success != nil
}

// GetAuthErr returns the value of AuthErr if it is set or its
// zero value if it is unset.
func (v *SimpleService_GetProfile_Result) GetAuthErr() (o *AuthErr) {
	if v != nil && v.AuthErr != nil {
		return v.AuthErr
	}

	return
}

// IsSetAuthErr returns true if AuthErr is not nil.
func (v *SimpleService_GetProfile_Result) IsSetAuthErr() bool {
	return v != nil && v.AuthErr != nil
}

// MethodName returns the name of the Thrift function as specified in
// the IDL, for which this struct represent the result.
//
// This will always be "getProfile" for this struct.
func (v *SimpleService_GetProfile_Result) MethodName() string {
	return "getProfile"
}

// EnvelopeType returns the kind of value inside this struct.
//
// This will always be Reply for this struct.
func (v *SimpleService_GetProfile_Result) EnvelopeType() wire.EnvelopeType {
	return wire.Reply
}

// SimpleService_HeaderSchema_Args represents the arguments for the SimpleService.headerSchema function.
//
// The arguments for headerSchema are sent and received over the wire as this struct.
type SimpleService_HeaderSchema_Args struct {
	Req *HeaderSchema `json:"req,required"`
}

// ToWire translates a SimpleService_HeaderSchema_Args struct into a Thrift-level intermediate
// representation. This intermediate representation may be serialized
// into bytes using a ThriftRW protocol implementation.
//
// An error is returned if the struct or any of its fields failed to
// validate.
//
//	x, err := v.ToWire()
//	if err != nil {
//	  return err
//	}
//
//	if err := binaryProtocol.Encode(x, writer); err != nil {
//	  return err
//	}
func (v *SimpleService_HeaderSchema_Args) ToWire() (wire.Value, error) {
	var (
		fields [1]wire.Field
		i      int = 0
		w      wire.Value
		err    error
	)

	if v.Req == nil {
		return w, errors.New("field Req of SimpleService_HeaderSchema_Args is required")
	}
	w, err = v.Req.ToWire()
	if err != nil {
		return w, err
	}
	fields[i] = wire.Field{ID: 1, Value: w}
	i++

	return wire.NewValueStruct(wire.Struct{Fields: fields[:i]}), nil
}

func _HeaderSchema_Read(w wire.Value) (*HeaderSchema, error) {
	var v HeaderSchema
	err := v.FromWire(w)
	return &v, err
}

// FromWire deserializes a SimpleService_HeaderSchema_Args struct from its Thrift-level
// representation. The Thrift-level representation may be obtained
// from a ThriftRW protocol implementation.
//
// An error is returned if we were unable to build a SimpleService_HeaderSchema_Args struct
// from the provided intermediate representation.
//
//	x, err := binaryProtocol.Decode(reader, wire.TStruct)
//	if err != nil {
//	  return nil, err
//	}
//
//	var v SimpleService_HeaderSchema_Args
//	if err := v.FromWire(x); err != nil {
//	  return nil, err
//	}
//	return &v, nil
func (v *SimpleService_HeaderSchema_Args) FromWire(w wire.Value) error {
	var err error

	reqIsSet := false

	for _, field := range w.GetStruct().Fields {
		switch field.ID {
		case 1:
			if field.Value.Type() == wire.TStruct {
				v.Req, err = _HeaderSchema_Read(field.Value)
				if err != nil {
					return err
				}
				reqIsSet = true
			}
		}
	}

	if !reqIsSet {
		return errors.New("field Req of SimpleService_HeaderSchema_Args is required")
	}

	return nil
}

// Encode serializes a SimpleService_HeaderSchema_Args struct directly into bytes, without going
// through an intermediary type.
//
// An error is returned if a SimpleService_HeaderSchema_Args struct could not be encoded.
func (v *SimpleService_HeaderSchema_Args) Encode(sw stream.Writer) error {
	if err := sw.WriteStructBegin(); err != nil {
		return err
	}

	if v.Req == nil {
		return errors.New("field Req of SimpleService_HeaderSchema_Args is required")
	}
	if err := sw.WriteFieldBegin(stream.FieldHeader{ID: 1, Type: wire.TStruct}); err != nil {
		return err
	}
	if err := v.Req.Encode(sw); err != nil {
		return err
	}
	if err := sw.WriteFieldEnd(); err != nil {
		return err
	}

	return sw.WriteStructEnd()
}

func _HeaderSchema_Decode(sr stream.Reader) (*HeaderSchema, error) {
	var v HeaderSchema
	err := v.Decode(sr)
	return &v, err
}

// Decode deserializes a SimpleService_HeaderSchema_Args struct directly from its Thrift-level
// representation, without going through an intemediary type.
//
// An error is returned if a SimpleService_HeaderSchema_Args struct could not be generated from the wire
// representation.
func (v *SimpleService_HeaderSchema_Args) Decode(sr stream.Reader) error {

	reqIsSet := false

	if err := sr.ReadStructBegin(); err != nil {
		return err
	}

	fh, ok, err := sr.ReadFieldBegin()
	if err != nil {
		return err
	}

	for ok {
		switch {
		case fh.ID == 1 && fh.Type == wire.TStruct:
			v.Req, err = _HeaderSchema_Decode(sr)
			if err != nil {
				return err
			}
			reqIsSet = true
		default:
			if err := sr.Skip(fh.Type); err != nil {
				return err
			}
		}

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

		if fh, ok, err = sr.ReadFieldBegin(); err != nil {
			return err
		}
	}

	if err := sr.ReadStructEnd(); err != nil {
		return err
	}

	if !reqIsSet {
		return errors.New("field Req of SimpleService_HeaderSchema_Args is required")
	}

	return nil
}

// String returns a readable string representation of a SimpleService_HeaderSchema_Args
// struct.
func (v *SimpleService_HeaderSchema_Args) String() string {
	if v == nil {
		return "<nil>"
	}

	var fields [1]string
	i := 0
	fields[i] = fmt.Sprintf("Req: %v", v.Req)
	i++

	return fmt.Sprintf("SimpleService_HeaderSchema_Args{%v}", strings.Join(fields[:i], ", "))
}

// Equals returns true if all the fields of this SimpleService_HeaderSchema_Args match the
// provided SimpleService_HeaderSchema_Args.
//
// This function performs a deep comparison.
func (v *SimpleService_HeaderSchema_Args) Equals(rhs *SimpleService_HeaderSchema_Args) bool {
	if v == nil {
		return rhs == nil
	} else if rhs == nil {
		return false
	}
	if !v.Req.Equals(rhs.Req) {
		return false
	}

	return true
}

// MarshalLogObject implements zapcore.ObjectMarshaler, enabling
// fast logging of SimpleService_HeaderSchema_Args.
func (v *SimpleService_HeaderSchema_Args) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
	if v == nil {
		return nil
	}
	err = multierr.Append(err, enc.AddObject("req", v.Req))
	return err
}

// GetReq returns the value of Req if it is set or its
// zero value if it is unset.
func (v *SimpleService_HeaderSchema_Args) GetReq() (o *HeaderSchema) {
	if v != nil {
		o = v.Req
	}
	return
}

// IsSetReq returns true if Req is not nil.
func (v *SimpleService_HeaderSchema_Args) IsSetReq() bool {
	return v != nil && v.Req != nil
}

// MethodName returns the name of the Thrift function as specified in
// the IDL, for which this struct represent the arguments.
//
// This will always be "headerSchema" for this struct.
func (v *SimpleService_HeaderSchema_Args) MethodName() string {
	return "headerSchema"
}

// EnvelopeType returns the kind of value inside this struct.
//
// This will always be Call for this struct.
func (v *SimpleService_HeaderSchema_Args) EnvelopeType() wire.EnvelopeType {
	return wire.Call
}

// SimpleService_HeaderSchema_Helper provides functions that aid in handling the
// parameters and return values of the SimpleService.headerSchema
// function.
var SimpleService_HeaderSchema_Helper = struct {
	// Args accepts the parameters of headerSchema in-order and returns
	// the arguments struct for the function.
	Args func(
		req *HeaderSchema,
	) *SimpleService_HeaderSchema_Args

	// IsException returns true if the given error can be thrown
	// by headerSchema.
	//
	// An error can be thrown by headerSchema only if the
	// corresponding exception type was mentioned in the 'throws'
	// section for it in the Thrift file.
	IsException func(error) bool

	// WrapResponse returns the result struct for headerSchema
	// given its return value and error.
	//
	// This allows mapping values and errors returned by
	// headerSchema into a serializable result struct.
	// WrapResponse returns a non-nil error if the provided
	// error cannot be thrown by headerSchema
	//
	//   value, err := headerSchema(args)
	//   result, err := SimpleService_HeaderSchema_Helper.WrapResponse(value, err)
	//   if err != nil {
	//     return fmt.Errorf("unexpected error from headerSchema: %v", err)
	//   }
	//   serialize(result)
	WrapResponse func(*HeaderSchema, error) (*SimpleService_HeaderSchema_Result, error)

	// UnwrapResponse takes the result struct for headerSchema
	// and returns the value or error returned by it.
	//
	// The error is non-nil only if headerSchema threw an
	// exception.
	//
	//   result := deserialize(bytes)
	//   value, err := SimpleService_HeaderSchema_Helper.UnwrapResponse(result)
	UnwrapResponse func(*SimpleService_HeaderSchema_Result) (*HeaderSchema, error)
}{}

func init() {
	SimpleService_HeaderSchema_Helper.Args = func(
		req *HeaderSchema,
	) *SimpleService_HeaderSchema_Args {
		return &SimpleService_HeaderSchema_Args{
			Req: req,
		}
	}

	SimpleService_HeaderSchema_Helper.IsException = func(err error) bool {
		switch err.(type) {
		case *AuthErr:
			return true
		case *OtherAuthErr:
			return true
		default:
			return false
		}
	}

	SimpleService_HeaderSchema_Helper.WrapResponse = func(success *HeaderSchema, err error) (*SimpleService_HeaderSchema_Result, error) {
		if err == nil {
			return &SimpleService_HeaderSchema_Result{Success: success}, nil
		}

		switch e := err.(type) {
		case *AuthErr:
			if e == nil {
				return nil, errors.New("WrapResponse received non-nil error type with nil value for SimpleService_HeaderSchema_Result.AuthErr")
			}
			return &SimpleService_HeaderSchema_Result{AuthErr: e}, nil
		case *OtherAuthErr:
			if e == nil {
				return nil, errors.New("WrapResponse received non-nil error type with nil value for SimpleService_HeaderSchema_Result.OtherAuthErr")
			}
			return &SimpleService_HeaderSchema_Result{OtherAuthErr: e}, nil
		}

		return nil, err
	}
	SimpleService_HeaderSchema_Helper.UnwrapResponse = func(result *SimpleService_HeaderSchema_Result) (success *HeaderSchema, err error) {
		if result.AuthErr != nil {
			err = result.AuthErr
			return
		}
		if result.OtherAuthErr != nil {
			err = result.OtherAuthErr
			return
		}

		if result.Success != nil {
			success = result.Success
			return
		}

		err = errors.New("expected a non-void result")
		return
	}

}

// SimpleService_HeaderSchema_Result represents the result of a SimpleService.headerSchema function call.
//
// The result of a headerSchema execution is sent and received over the wire as this struct.
//
// Success is set only if the function did not throw an exception.
type SimpleService_HeaderSchema_Result struct {
	// Value returned by headerSchema after a successful execution.
	Success      *HeaderSchema `json:"success,omitempty"`
	AuthErr      *AuthErr      `json:"authErr,omitempty"`
	OtherAuthErr *OtherAuthErr `json:"otherAuthErr,omitempty"`
}

// ToWire translates a SimpleService_HeaderSchema_Result struct into a Thrift-level intermediate
// representation. This intermediate representation may be serialized
// into bytes using a ThriftRW protocol implementation.
//
// An error is returned if the struct or any of its fields failed to
// validate.
//
//	x, err := v.ToWire()
//	if err != nil {
//	  return err
//	}
//
//	if err := binaryProtocol.Encode(x, writer); err != nil {
//	  return err
//	}
func (v *SimpleService_HeaderSchema_Result) ToWire() (wire.Value, error) {
	var (
		fields [3]wire.Field
		i      int = 0
		w      wire.Value
		err    error
	)

	if v.Success != nil {
		w, err = v.Success.ToWire()
		if err != nil {
			return w, err
		}
		fields[i] = wire.Field{ID: 0, Value: w}
		i++
	}
	if v.AuthErr != nil {
		w, err = v.AuthErr.ToWire()
		if err != nil {
			return w, err
		}
		fields[i] = wire.Field{ID: 1, Value: w}
		i++
	}
	if v.OtherAuthErr != nil {
		w, err = v.OtherAuthErr.ToWire()
		if err != nil {
			return w, err
		}
		fields[i] = wire.Field{ID: 2, Value: w}
		i++
	}

	if i != 1 {
		return wire.Value{}, fmt.Errorf("SimpleService_HeaderSchema_Result should have exactly one field: got %v fields", i)
	}

	return wire.NewValueStruct(wire.Struct{Fields: fields[:i]}), nil
}

// FromWire deserializes a SimpleService_HeaderSchema_Result struct from its Thrift-level
// representation. The Thrift-level representation may be obtained
// from a ThriftRW protocol implementation.
//
// An error is returned if we were unable to build a SimpleService_HeaderSchema_Result struct
// from the provided intermediate representation.
//
//	x, err := binaryProtocol.Decode(reader, wire.TStruct)
//	if err != nil {
//	  return nil, err
//	}
//
//	var v SimpleService_HeaderSchema_Result
//	if err := v.FromWire(x); err != nil {
//	  return nil, err
//	}
//	return &v, nil
func (v *SimpleService_HeaderSchema_Result) FromWire(w wire.Value) error {
	var err error

	for _, field := range w.GetStruct().Fields {
		switch field.ID {
		case 0:
			if field.Value.Type() == wire.TStruct {
				v.Success, err = _HeaderSchema_Read(field.Value)
				if err != nil {
					return err
				}

			}
		case 1:
			if field.Value.Type() == wire.TStruct {
				v.AuthErr, err = _AuthErr_Read(field.Value)
				if err != nil {
					return err
				}

			}
		case 2:
			if field.Value.Type() == wire.TStruct {
				v.OtherAuthErr, err = _OtherAuthErr_Read(field.Value)
				if err != nil {
					return err
				}

			}
		}
	}

	count := 0
	if v.Success != nil {
		count++
	}
	if v.AuthErr != nil {
		count++
	}
	if v.OtherAuthErr != nil {
		count++
	}
	if count != 1 {
		return fmt.Errorf("SimpleService_HeaderSchema_Result should have exactly one field: got %v fields", count)
	}

	return nil
}

// Encode serializes a SimpleService_HeaderSchema_Result struct directly into bytes, without going
// through an intermediary type.
//
// An error is returned if a SimpleService_HeaderSchema_Result struct could not be encoded.
func (v *SimpleService_HeaderSchema_Result) Encode(sw stream.Writer) error {
	if err := sw.WriteStructBegin(); err != nil {
		return err
	}

	if v.Success != nil {
		if err := sw.WriteFieldBegin(stream.FieldHeader{ID: 0, Type: wire.TStruct}); err != nil {
			return err
		}
		if err := v.Success.Encode(sw); err != nil {
			return err
		}
		if err := sw.WriteFieldEnd(); err != nil {
			return err
		}
	}

	if v.AuthErr != nil {
		if err := sw.WriteFieldBegin(stream.FieldHeader{ID: 1, Type: wire.TStruct}); err != nil {
			return err
		}
		if err := v.AuthErr.Encode(sw); err != nil {
			return err
		}
		if err := sw.WriteFieldEnd(); err != nil {
			return err
		}
	}

	if v.OtherAuthErr != nil {
		if err := sw.WriteFieldBegin(stream.FieldHeader{ID: 2, Type: wire.TStruct}); err != nil {
			return err
		}
		if err := v.OtherAuthErr.Encode(sw); err != nil {
			return err
		}
		if err := sw.WriteFieldEnd(); err != nil {
			return err
		}
	}

	count := 0
	if v.Success != nil {
		count++
	}
	if v.AuthErr != nil {
		count++
	}
	if v.OtherAuthErr != nil {
		count++
	}

	if count != 1 {
		return fmt.Errorf("SimpleService_HeaderSchema_Result should have exactly one field: got %v fields", count)
	}

	return sw.WriteStructEnd()
}

// Decode deserializes a SimpleService_HeaderSchema_Result struct directly from its Thrift-level
// representation, without going through an intemediary type.
//
// An error is returned if a SimpleService_HeaderSchema_Result struct could not be generated from the wire
// representation.
func (v *SimpleService_HeaderSchema_Result) Decode(sr stream.Reader) error {

	if err := sr.ReadStructBegin(); err != nil {
		return err
	}

	fh, ok, err := sr.ReadFieldBegin()
	if err != nil {
		return err
	}

	for ok {
		switch {
		case fh.ID == 0 && fh.Type == wire.TStruct:
			v.Success, err = _HeaderSchema_Decode(sr)
			if err != nil {
				return err
			}

		case fh.ID == 1 && fh.Type == wire.TStruct:
			v.AuthErr, err = _AuthErr_Decode(sr)
			if err != nil {
				return err
			}

		case fh.ID == 2 && fh.Type == wire.TStruct:
			v.OtherAuthErr, err = _OtherAuthErr_Decode(sr)
			if err != nil {
				return err
			}

		default:
			if err := sr.Skip(fh.Type); err != nil {
				return err
			}
		}

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

		if fh, ok, err = sr.ReadFieldBegin(); err != nil {
			return err
		}
	}

	if err := sr.ReadStructEnd(); err != nil {
		return err
	}

	count := 0
	if v.Success != nil {
		count++
	}
	if v.AuthErr != nil {
		count++
	}
	if v.OtherAuthErr != nil {
		count++
	}
	if count != 1 {
		return fmt.Errorf("SimpleService_HeaderSchema_Result should have exactly one field: got %v fields", count)
	}

	return nil
}

// String returns a readable string representation of a SimpleService_HeaderSchema_Result
// struct.
func (v *SimpleService_HeaderSchema_Result) String() string {
	if v == nil {
		return "<nil>"
	}

	var fields [3]string
	i := 0
	if v.Success != nil {
		fields[i] = fmt.Sprintf("Success: %v", v.Success)
		i++
	}
	if v.AuthErr != nil {
		fields[i] = fmt.Sprintf("AuthErr: %v", v.AuthErr)
		i++
	}
	if v.OtherAuthErr != nil {
		fields[i] = fmt.Sprintf("OtherAuthErr: %v", v.OtherAuthErr)
		i++
	}

	return fmt.Sprintf("SimpleService_HeaderSchema_Result{%v}", strings.Join(fields[:i], ", "))
}

// Equals returns true if all the fields of this SimpleService_HeaderSchema_Result match the
// provided SimpleService_HeaderSchema_Result.
//
// This function performs a deep comparison.
func (v *SimpleService_HeaderSchema_Result) Equals(rhs *SimpleService_HeaderSchema_Result) bool {
	if v == nil {
		return rhs == nil
	} else if rhs == nil {
		return false
	}
	if !((v.Success == nil && rhs.Success == nil) || (v.Success != nil && rhs.Success != nil && v.Success.Equals(rhs.Success))) {
		return false
	}
	if !((v.AuthErr == nil && rhs.AuthErr == nil) || (v.AuthErr != nil && rhs.AuthErr != nil && v.AuthErr.Equals(rhs.AuthErr))) {
		return false
	}
	if !((v.OtherAuthErr == nil && rhs.OtherAuthErr == nil) || (v.OtherAuthErr != nil && rhs.OtherAuthErr != nil && v.OtherAuthErr.Equals(rhs.OtherAuthErr))) {
		return false
	}

	return true
}

// MarshalLogObject implements zapcore.ObjectMarshaler, enabling
// fast logging of SimpleService_HeaderSchema_Result.
func (v *SimpleService_HeaderSchema_Result) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
	if v == nil {
		return nil
	}
	if v.Success != nil {
		err = multierr.Append(err, enc.AddObject("success", v.Success))
	}
	if v.AuthErr != nil {
		err = multierr.Append(err, enc.AddObject("authErr", v.AuthErr))
	}
	if v.OtherAuthErr != nil {
		err = multierr.Append(err, enc.AddObject("otherAuthErr", v.OtherAuthErr))
	}
	return err
}

// GetSuccess returns the value of Success if it is set or its
// zero value if it is unset.
func (v *SimpleService_HeaderSchema_Result) GetSuccess() (o *HeaderSchema) {
	if v != nil && v.Success != nil {
		return v.Success
	}

	return
}

// IsSetSuccess returns true if Success is not nil.
func (v *SimpleService_HeaderSchema_Result) IsSetSuccess() bool {
	return v != nil && v.Success != nil
}

// GetAuthErr returns the value of AuthErr if it is set or its
// zero value if it is unset.
func (v *SimpleService_HeaderSchema_Result) GetAuthErr() (o *AuthErr) {
	if v != nil && v.AuthErr != nil {
		return v.AuthErr
	}

	return
}

// IsSetAuthErr returns true if AuthErr is not nil.
func (v *SimpleService_HeaderSchema_Result) IsSetAuthErr() bool {
	return v != nil && v.AuthErr != nil
}

// GetOtherAuthErr returns the value of OtherAuthErr if it is set or its
// zero value if it is unset.
func (v *SimpleService_HeaderSchema_Result) GetOtherAuthErr() (o *OtherAuthErr) {
	if v != nil && v.OtherAuthErr != nil {
		return v.OtherAuthErr
	}

	return
}

// IsSetOtherAuthErr returns true if OtherAuthErr is not nil.
func (v *SimpleService_HeaderSchema_Result) IsSetOtherAuthErr() bool {
	return v != nil && v.OtherAuthErr != nil
}

// MethodName returns the name of the Thrift function as specified in
// the IDL, for which this struct represent the result.
//
// This will always be "headerSchema" for this struct.
func (v *SimpleService_HeaderSchema_Result) MethodName() string {
	return "headerSchema"
}

// EnvelopeType returns the kind of value inside this struct.
//
// This will always be Reply for this struct.
func (v *SimpleService_HeaderSchema_Result) EnvelopeType() wire.EnvelopeType {
	return wire.Reply
}

// SimpleService_Ping_Args represents the arguments for the SimpleService.ping function.
//
// The arguments for ping are sent and received over the wire as this struct.
type SimpleService_Ping_Args struct {
}

// ToWire translates a SimpleService_Ping_Args struct into a Thrift-level intermediate
// representation. This intermediate representation may be serialized
// into bytes using a ThriftRW protocol implementation.
//
// An error is returned if the struct or any of its fields failed to
// validate.
//
//	x, err := v.ToWire()
//	if err != nil {
//	  return err
//	}
//
//	if err := binaryProtocol.Encode(x, writer); err != nil {
//	  return err
//	}
func (v *SimpleService_Ping_Args) ToWire() (wire.Value, error) {
	var (
		fields [0]wire.Field
		i      int = 0
	)

	return wire.NewValueStruct(wire.Struct{Fields: fields[:i]}), nil
}

// FromWire deserializes a SimpleService_Ping_Args struct from its Thrift-level
// representation. The Thrift-level representation may be obtained
// from a ThriftRW protocol implementation.
//
// An error is returned if we were unable to build a SimpleService_Ping_Args struct
// from the provided intermediate representation.
//
//	x, err := binaryProtocol.Decode(reader, wire.TStruct)
//	if err != nil {
//	  return nil, err
//	}
//
//	var v SimpleService_Ping_Args
//	if err := v.FromWire(x); err != nil {
//	  return nil, err
//	}
//	return &v, nil
func (v *SimpleService_Ping_Args) FromWire(w wire.Value) error {

	for _, field := range w.GetStruct().Fields {
		switch field.ID {
		}
	}

	return nil
}

// Encode serializes a SimpleService_Ping_Args struct directly into bytes, without going
// through an intermediary type.
//
// An error is returned if a SimpleService_Ping_Args struct could not be encoded.
func (v *SimpleService_Ping_Args) Encode(sw stream.Writer) error {
	if err := sw.WriteStructBegin(); err != nil {
		return err
	}

	return sw.WriteStructEnd()
}

// Decode deserializes a SimpleService_Ping_Args struct directly from its Thrift-level
// representation, without going through an intemediary type.
//
// An error is returned if a SimpleService_Ping_Args struct could not be generated from the wire
// representation.
func (v *SimpleService_Ping_Args) Decode(sr stream.Reader) error {

	if err := sr.ReadStructBegin(); err != nil {
		return err
	}

	fh, ok, err := sr.ReadFieldBegin()
	if err != nil {
		return err
	}

	for ok {
		switch {
		default:
			if err := sr.Skip(fh.Type); err != nil {
				return err
			}
		}

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

		if fh, ok, err = sr.ReadFieldBegin(); err != nil {
			return err
		}
	}

	if err := sr.ReadStructEnd(); err != nil {
		return err
	}

	return nil
}

// String returns a readable string representation of a SimpleService_Ping_Args
// struct.
func (v *SimpleService_Ping_Args) String() string {
	if v == nil {
		return "<nil>"
	}

	var fields [0]string
	i := 0

	return fmt.Sprintf("SimpleService_Ping_Args{%v}", strings.Join(fields[:i], ", "))
}

// Equals returns true if all the fields of this SimpleService_Ping_Args match the
// provided SimpleService_Ping_Args.
//
// This function performs a deep comparison.
func (v *SimpleService_Ping_Args) Equals(rhs *SimpleService_Ping_Args) bool {
	if v == nil {
		return rhs == nil
	} else if rhs == nil {
		return false
	}

	return true
}

// MarshalLogObject implements zapcore.ObjectMarshaler, enabling
// fast logging of SimpleService_Ping_Args.
func (v *SimpleService_Ping_Args) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
	if v == nil {
		return nil
	}
	return err
}

// MethodName returns the name of the Thrift function as specified in
// the IDL, for which this struct represent the arguments.
//
// This will always be "ping" for this struct.
func (v *SimpleService_Ping_Args) MethodName() string {
	return "ping"
}

// EnvelopeType returns the kind of value inside this struct.
//
// This will always be Call for this struct.
func (v *SimpleService_Ping_Args) EnvelopeType() wire.EnvelopeType {
	return wire.Call
}

// SimpleService_Ping_Helper provides functions that aid in handling the
// parameters and return values of the SimpleService.ping
// function.
var SimpleService_Ping_Helper = struct {
	// Args accepts the parameters of ping in-order and returns
	// the arguments struct for the function.
	Args func() *SimpleService_Ping_Args

	// IsException returns true if the given error can be thrown
	// by ping.
	//
	// An error can be thrown by ping only if the
	// corresponding exception type was mentioned in the 'throws'
	// section for it in the Thrift file.
	IsException func(error) bool

	// WrapResponse returns the result struct for ping
	// given its return value and error.
	//
	// This allows mapping values and errors returned by
	// ping into a serializable result struct.
	// WrapResponse returns a non-nil error if the provided
	// error cannot be thrown by ping
	//
	//   value, err := ping(args)
	//   result, err := SimpleService_Ping_Helper.WrapResponse(value, err)
	//   if err != nil {
	//     return fmt.Errorf("unexpected error from ping: %v", err)
	//   }
	//   serialize(result)
	WrapResponse func(*BazResponse, error) (*SimpleService_Ping_Result, error)

	// UnwrapResponse takes the result struct for ping
	// and returns the value or error returned by it.
	//
	// The error is non-nil only if ping threw an
	// exception.
	//
	//   result := deserialize(bytes)
	//   value, err := SimpleService_Ping_Helper.UnwrapResponse(result)
	UnwrapResponse func(*SimpleService_Ping_Result) (*BazResponse, error)
}{}

func init() {
	SimpleService_Ping_Helper.Args = func() *SimpleService_Ping_Args {
		return &SimpleService_Ping_Args{}
	}

	SimpleService_Ping_Helper.IsException = func(err error) bool {
		switch err.(type) {
		default:
			return false
		}
	}

	SimpleService_Ping_Helper.WrapResponse = func(success *BazResponse, err error) (*SimpleService_Ping_Result, error) {
		if err == nil {
			return &SimpleService_Ping_Result{Success: success}, nil
		}

		return nil, err
	}
	SimpleService_Ping_Helper.UnwrapResponse = func(result *SimpleService_Ping_Result) (success *BazResponse, err error) {

		if result.Success != nil {
			success = result.Success
			return
		}

		err = errors.New("expected a non-void result")
		return
	}

}

// SimpleService_Ping_Result represents the result of a SimpleService.ping function call.
//
// The result of a ping execution is sent and received over the wire as this struct.
//
// Success is set only if the function did not throw an exception.
type SimpleService_Ping_Result struct {
	// Value returned by ping after a successful execution.
	Success *BazResponse `json:"success,omitempty"`
}

// ToWire translates a SimpleService_Ping_Result struct into a Thrift-level intermediate
// representation. This intermediate representation may be serialized
// into bytes using a ThriftRW protocol implementation.
//
// An error is returned if the struct or any of its fields failed to
// validate.
//
//	x, err := v.ToWire()
//	if err != nil {
//	  return err
//	}
//
//	if err := binaryProtocol.Encode(x, writer); err != nil {
//	  return err
//	}
func (v *SimpleService_Ping_Result) ToWire() (wire.Value, error) {
	var (
		fields [1]wire.Field
		i      int = 0
		w      wire.Value
		err    error
	)

	if v.Success != nil {
		w, err = v.Success.ToWire()
		if err != nil {
			return w, err
		}
		fields[i] = wire.Field{ID: 0, Value: w}
		i++
	}

	if i != 1 {
		return wire.Value{}, fmt.Errorf("SimpleService_Ping_Result should have exactly one field: got %v fields", i)
	}

	return wire.NewValueStruct(wire.Struct{Fields: fields[:i]}), nil
}

// FromWire deserializes a SimpleService_Ping_Result struct from its Thrift-level
// representation. The Thrift-level representation may be obtained
// from a ThriftRW protocol implementation.
//
// An error is returned if we were unable to build a SimpleService_Ping_Result struct
// from the provided intermediate representation.
//
//	x, err := binaryProtocol.Decode(reader, wire.TStruct)
//	if err != nil {
//	  return nil, err
//	}
//
//	var v SimpleService_Ping_Result
//	if err := v.FromWire(x); err != nil {
//	  return nil, err
//	}
//	return &v, nil
func (v *SimpleService_Ping_Result) FromWire(w wire.Value) error {
	var err error

	for _, field := range w.GetStruct().Fields {
		switch field.ID {
		case 0:
			if field.Value.Type() == wire.TStruct {
				v.Success, err = _BazResponse_Read(field.Value)
				if err != nil {
					return err
				}

			}
		}
	}

	count := 0
	if v.Success != nil {
		count++
	}
	if count != 1 {
		return fmt.Errorf("SimpleService_Ping_Result should have exactly one field: got %v fields", count)
	}

	return nil
}

// Encode serializes a SimpleService_Ping_Result struct directly into bytes, without going
// through an intermediary type.
//
// An error is returned if a SimpleService_Ping_Result struct could not be encoded.
func (v *SimpleService_Ping_Result) Encode(sw stream.Writer) error {
	if err := sw.WriteStructBegin(); err != nil {
		return err
	}

	if v.Success != nil {
		if err := sw.WriteFieldBegin(stream.FieldHeader{ID: 0, Type: wire.TStruct}); err != nil {
			return err
		}
		if err := v.Success.Encode(sw); err != nil {
			return err
		}
		if err := sw.WriteFieldEnd(); err != nil {
			return err
		}
	}

	count := 0
	if v.Success != nil {
		count++
	}

	if count != 1 {
		return fmt.Errorf("SimpleService_Ping_Result should have exactly one field: got %v fields", count)
	}

	return sw.WriteStructEnd()
}

// Decode deserializes a SimpleService_Ping_Result struct directly from its Thrift-level
// representation, without going through an intemediary type.
//
// An error is returned if a SimpleService_Ping_Result struct could not be generated from the wire
// representation.
func (v *SimpleService_Ping_Result) Decode(sr stream.Reader) error {

	if err := sr.ReadStructBegin(); err != nil {
		return err
	}

	fh, ok, err := sr.ReadFieldBegin()
	if err != nil {
		return err
	}

	for ok {
		switch {
		case fh.ID == 0 && fh.Type == wire.TStruct:
			v.Success, err = _BazResponse_Decode(sr)
			if err != nil {
				return err
			}

		default:
			if err := sr.Skip(fh.Type); err != nil {
				return err
			}
		}

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

		if fh, ok, err = sr.ReadFieldBegin(); err != nil {
			return err
		}
	}

	if err := sr.ReadStructEnd(); err != nil {
		return err
	}

	count := 0
	if v.Success != nil {
		count++
	}
	if count != 1 {
		return fmt.Errorf("SimpleService_Ping_Result should have exactly one field: got %v fields", count)
	}

	return nil
}

// String returns a readable string representation of a SimpleService_Ping_Result
// struct.
func (v *SimpleService_Ping_Result) String() string {
	if v == nil {
		return "<nil>"
	}

	var fields [1]string
	i := 0
	if v.Success != nil {
		fields[i] = fmt.Sprintf("Success: %v", v.Success)
		i++
	}

	return fmt.Sprintf("SimpleService_Ping_Result{%v}", strings.Join(fields[:i], ", "))
}

// Equals returns true if all the fields of this SimpleService_Ping_Result match the
// provided SimpleService_Ping_Result.
//
// This function performs a deep comparison.
func (v *SimpleService_Ping_Result) Equals(rhs *SimpleService_Ping_Result) bool {
	if v == nil {
		return rhs == nil
	} else if rhs == nil {
		return false
	}
	if !((v.Success == nil && rhs.Success == nil) || (v.Success != nil && rhs.Success != nil && v.Success.Equals(rhs.Success))) {
		return false
	}

	return true
}

// MarshalLogObject implements zapcore.ObjectMarshaler, enabling
// fast logging of SimpleService_Ping_Result.
func (v *SimpleService_Ping_Result) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
	if v == nil {
		return nil
	}
	if v.Success != nil {
		err = multierr.Append(err, enc.AddObject("success", v.Success))
	}
	return err
}

// GetSuccess returns the value of Success if it is set or its
// zero value if it is unset.
func (v *SimpleService_Ping_Result) GetSuccess() (o *BazResponse) {
	if v != nil && v.Success != nil {
		return v.Success
	}

	return
}

// IsSetSuccess returns true if Success is not nil.
func (v *SimpleService_Ping_Result) IsSetSuccess() bool {
	return v != nil && v.Success != nil
}

// MethodName returns the name of the Thrift function as specified in
// the IDL, for which this struct represent the result.
//
// This will always be "ping" for this struct.
func (v *SimpleService_Ping_Result) MethodName() string {
	return "ping"
}

// EnvelopeType returns the kind of value inside this struct.
//
// This will always be Reply for this struct.
func (v *SimpleService_Ping_Result) EnvelopeType() wire.EnvelopeType {
	return wire.Reply
}

// SimpleService_SillyNoop_Args represents the arguments for the SimpleService.sillyNoop function.
//
// The arguments for sillyNoop are sent and received over the wire as this struct.
type SimpleService_SillyNoop_Args struct {
}

// ToWire translates a SimpleService_SillyNoop_Args struct into a Thrift-level intermediate
// representation. This intermediate representation may be serialized
// into bytes using a ThriftRW protocol implementation.
//
// An error is returned if the struct or any of its fields failed to
// validate.
//
//	x, err := v.ToWire()
//	if err != nil {
//	  return err
//	}
//
//	if err := binaryProtocol.Encode(x, writer); err != nil {
//	  return err
//	}
func (v *SimpleService_SillyNoop_Args) ToWire() (wire.Value, error) {
	var (
		fields [0]wire.Field
		i      int = 0
	)

	return wire.NewValueStruct(wire.Struct{Fields: fields[:i]}), nil
}

// FromWire deserializes a SimpleService_SillyNoop_Args struct from its Thrift-level
// representation. The Thrift-level representation may be obtained
// from a ThriftRW protocol implementation.
//
// An error is returned if we were unable to build a SimpleService_SillyNoop_Args struct
// from the provided intermediate representation.
//
//	x, err := binaryProtocol.Decode(reader, wire.TStruct)
//	if err != nil {
//	  return nil, err
//	}
//
//	var v SimpleService_SillyNoop_Args
//	if err := v.FromWire(x); err != nil {
//	  return nil, err
//	}
//	return &v, nil
func (v *SimpleService_SillyNoop_Args) FromWire(w wire.Value) error {

	for _, field := range w.GetStruct().Fields {
		switch field.ID {
		}
	}

	return nil
}

// Encode serializes a SimpleService_SillyNoop_Args struct directly into bytes, without going
// through an intermediary type.
//
// An error is returned if a SimpleService_SillyNoop_Args struct could not be encoded.
func (v *SimpleService_SillyNoop_Args) Encode(sw stream.Writer) error {
	if err := sw.WriteStructBegin(); err != nil {
		return err
	}

	return sw.WriteStructEnd()
}

// Decode deserializes a SimpleService_SillyNoop_Args struct directly from its Thrift-level
// representation, without going through an intemediary type.
//
// An error is returned if a SimpleService_SillyNoop_Args struct could not be generated from the wire
// representation.
func (v *SimpleService_SillyNoop_Args) Decode(sr stream.Reader) error {

	if err := sr.ReadStructBegin(); err != nil {
		return err
	}

	fh, ok, err := sr.ReadFieldBegin()
	if err != nil {
		return err
	}

	for ok {
		switch {
		default:
			if err := sr.Skip(fh.Type); err != nil {
				return err
			}
		}

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

		if fh, ok, err = sr.ReadFieldBegin(); err != nil {
			return err
		}
	}

	if err := sr.ReadStructEnd(); err != nil {
		return err
	}

	return nil
}

// String returns a readable string representation of a SimpleService_SillyNoop_Args
// struct.
func (v *SimpleService_SillyNoop_Args) String() string {
	if v == nil {
		return "<nil>"
	}

	var fields [0]string
	i := 0

	return fmt.Sprintf("SimpleService_SillyNoop_Args{%v}", strings.Join(fields[:i], ", "))
}

// Equals returns true if all the fields of this SimpleService_SillyNoop_Args match the
// provided SimpleService_SillyNoop_Args.
//
// This function performs a deep comparison.
func (v *SimpleService_SillyNoop_Args) Equals(rhs *SimpleService_SillyNoop_Args) bool {
	if v == nil {
		return rhs == nil
	} else if rhs == nil {
		return false
	}

	return true
}

// MarshalLogObject implements zapcore.ObjectMarshaler, enabling
// fast logging of SimpleService_SillyNoop_Args.
func (v *SimpleService_SillyNoop_Args) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
	if v == nil {
		return nil
	}
	return err
}

// MethodName returns the name of the Thrift function as specified in
// the IDL, for which this struct represent the arguments.
//
// This will always be "sillyNoop" for this struct.
func (v *SimpleService_SillyNoop_Args) MethodName() string {
	return "sillyNoop"
}

// EnvelopeType returns the kind of value inside this struct.
//
// This will always be Call for this struct.
func (v *SimpleService_SillyNoop_Args) EnvelopeType() wire.EnvelopeType {
	return wire.Call
}

// SimpleService_SillyNoop_Helper provides functions that aid in handling the
// parameters and return values of the SimpleService.sillyNoop
// function.
var SimpleService_SillyNoop_Helper = struct {
	// Args accepts the parameters of sillyNoop in-order and returns
	// the arguments struct for the function.
	Args func() *SimpleService_SillyNoop_Args

	// IsException returns true if the given error can be thrown
	// by sillyNoop.
	//
	// An error can be thrown by sillyNoop only if the
	// corresponding exception type was mentioned in the 'throws'
	// section for it in the Thrift file.
	IsException func(error) bool

	// WrapResponse returns the result struct for sillyNoop
	// given the error returned by it. The provided error may
	// be nil if sillyNoop did not fail.
	//
	// This allows mapping errors returned by sillyNoop into a
	// serializable result struct. WrapResponse returns a
	// non-nil error if the provided error cannot be thrown by
	// sillyNoop
	//
	//   err := sillyNoop(args)
	//   result, err := SimpleService_SillyNoop_Helper.WrapResponse(err)
	//   if err != nil {
	//     return fmt.Errorf("unexpected error from sillyNoop: %v", err)
	//   }
	//   serialize(result)
	WrapResponse func(error) (*SimpleService_SillyNoop_Result, error)

	// UnwrapResponse takes the result struct for sillyNoop
	// and returns the erorr returned by it (if any).
	//
	// The error is non-nil only if sillyNoop threw an
	// exception.
	//
	//   result := deserialize(bytes)
	//   err := SimpleService_SillyNoop_Helper.UnwrapResponse(result)
	UnwrapResponse func(*SimpleService_SillyNoop_Result) error
}{}

func init() {
	SimpleService_SillyNoop_Helper.Args = func() *SimpleService_SillyNoop_Args {
		return &SimpleService_SillyNoop_Args{}
	}

	SimpleService_SillyNoop_Helper.IsException = func(err error) bool {
		switch err.(type) {
		case *AuthErr:
			return true
		case *ServerErr:
			return true
		default:
			return false
		}
	}

	SimpleService_SillyNoop_Helper.WrapResponse = func(err error) (*SimpleService_SillyNoop_Result, error) {
		if err == nil {
			return &SimpleService_SillyNoop_Result{}, nil
		}

		switch e := err.(type) {
		case *AuthErr:
			if e == nil {
				return nil, errors.New("WrapResponse received non-nil error type with nil value for SimpleService_SillyNoop_Result.AuthErr")
			}
			return &SimpleService_SillyNoop_Result{AuthErr: e}, nil
		case *ServerErr:
			if e == nil {
				return nil, errors.New("WrapResponse received non-nil error type with nil value for SimpleService_SillyNoop_Result.ServerErr")
			}
			return &SimpleService_SillyNoop_Result{ServerErr: e}, nil
		}

		return nil, err
	}
	SimpleService_SillyNoop_Helper.UnwrapResponse = func(result *SimpleService_SillyNoop_Result) (err error) {
		if result.AuthErr != nil {
			err = result.AuthErr
			return
		}
		if result.ServerErr != nil {
			err = result.ServerErr
			return
		}
		return
	}

}

// SimpleService_SillyNoop_Result represents the result of a SimpleService.sillyNoop function call.
//
// The result of a sillyNoop execution is sent and received over the wire as this struct.
type SimpleService_SillyNoop_Result struct {
	AuthErr   *AuthErr   `json:"authErr,omitempty"`
	ServerErr *ServerErr `json:"serverErr,omitempty"`
}

// ToWire translates a SimpleService_SillyNoop_Result struct into a Thrift-level intermediate
// representation. This intermediate representation may be serialized
// into bytes using a ThriftRW protocol implementation.
//
// An error is returned if the struct or any of its fields failed to
// validate.
//
//	x, err := v.ToWire()
//	if err != nil {
//	  return err
//	}
//
//	if err := binaryProtocol.Encode(x, writer); err != nil {
//	  return err
//	}
func (v *SimpleService_SillyNoop_Result) ToWire() (wire.Value, error) {
	var (
		fields [2]wire.Field
		i      int = 0
		w      wire.Value
		err    error
	)

	if v.AuthErr != nil {
		w, err = v.AuthErr.ToWire()
		if err != nil {
			return w, err
		}
		fields[i] = wire.Field{ID: 1, Value: w}
		i++
	}
	if v.ServerErr != nil {
		w, err = v.ServerErr.ToWire()
		if err != nil {
			return w, err
		}
		fields[i] = wire.Field{ID: 2, Value: w}
		i++
	}

	if i > 1 {
		return wire.Value{}, fmt.Errorf("SimpleService_SillyNoop_Result should have at most one field: got %v fields", i)
	}

	return wire.NewValueStruct(wire.Struct{Fields: fields[:i]}), nil
}

func _ServerErr_Read(w wire.Value) (*ServerErr, error) {
	var v ServerErr
	err := v.FromWire(w)
	return &v, err
}

// FromWire deserializes a SimpleService_SillyNoop_Result struct from its Thrift-level
// representation. The Thrift-level representation may be obtained
// from a ThriftRW protocol implementation.
//
// An error is returned if we were unable to build a SimpleService_SillyNoop_Result struct
// from the provided intermediate representation.
//
//	x, err := binaryProtocol.Decode(reader, wire.TStruct)
//	if err != nil {
//	  return nil, err
//	}
//
//	var v SimpleService_SillyNoop_Result
//	if err := v.FromWire(x); err != nil {
//	  return nil, err
//	}
//	return &v, nil
func (v *SimpleService_SillyNoop_Result) FromWire(w wire.Value) error {
	var err error

	for _, field := range w.GetStruct().Fields {
		switch field.ID {
		case 1:
			if field.Value.Type() == wire.TStruct {
				v.AuthErr, err = _AuthErr_Read(field.Value)
				if err != nil {
					return err
				}

			}
		case 2:
			if field.Value.Type() == wire.TStruct {
				v.ServerErr, err = _ServerErr_Read(field.Value)
				if err != nil {
					return err
				}

			}
		}
	}

	count := 0
	if v.AuthErr != nil {
		count++
	}
	if v.ServerErr != nil {
		count++
	}
	if count > 1 {
		return fmt.Errorf("SimpleService_SillyNoop_Result should have at most one field: got %v fields", count)
	}

	return nil
}

// Encode serializes a SimpleService_SillyNoop_Result struct directly into bytes, without going
// through an intermediary type.
//
// An error is returned if a SimpleService_SillyNoop_Result struct could not be encoded.
func (v *SimpleService_SillyNoop_Result) Encode(sw stream.Writer) error {
	if err := sw.WriteStructBegin(); err != nil {
		return err
	}

	if v.AuthErr != nil {
		if err := sw.WriteFieldBegin(stream.FieldHeader{ID: 1, Type: wire.TStruct}); err != nil {
			return err
		}
		if err := v.AuthErr.Encode(sw); err != nil {
			return err
		}
		if err := sw.WriteFieldEnd(); err != nil {
			return err
		}
	}

	if v.ServerErr != nil {
		if err := sw.WriteFieldBegin(stream.FieldHeader{ID: 2, Type: wire.TStruct}); err != nil {
			return err
		}
		if err := v.ServerErr.Encode(sw); err != nil {
			return err
		}
		if err := sw.WriteFieldEnd(); err != nil {
			return err
		}
	}

	count := 0
	if v.AuthErr != nil {
		count++
	}
	if v.ServerErr != nil {
		count++
	}

	if count > 1 {
		return fmt.Errorf("SimpleService_SillyNoop_Result should have at most one field: got %v fields", count)
	}

	return sw.WriteStructEnd()
}

func _ServerErr_Decode(sr stream.Reader) (*ServerErr, error) {
	var v ServerErr
	err := v.Decode(sr)
	return &v, err
}

// Decode deserializes a SimpleService_SillyNoop_Result struct directly from its Thrift-level
// representation, without going through an intemediary type.
//
// An error is returned if a SimpleService_SillyNoop_Result struct could not be generated from the wire
// representation.
func (v *SimpleService_SillyNoop_Result) Decode(sr stream.Reader) error {

	if err := sr.ReadStructBegin(); err != nil {
		return err
	}

	fh, ok, err := sr.ReadFieldBegin()
	if err != nil {
		return err
	}

	for ok {
		switch {
		case fh.ID == 1 && fh.Type == wire.TStruct:
			v.AuthErr, err = _AuthErr_Decode(sr)
			if err != nil {
				return err
			}

		case fh.ID == 2 && fh.Type == wire.TStruct:
			v.ServerErr, err = _ServerErr_Decode(sr)
			if err != nil {
				return err
			}

		default:
			if err := sr.Skip(fh.Type); err != nil {
				return err
			}
		}

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

		if fh, ok, err = sr.ReadFieldBegin(); err != nil {
			return err
		}
	}

	if err := sr.ReadStructEnd(); err != nil {
		return err
	}

	count := 0
	if v.AuthErr != nil {
		count++
	}
	if v.ServerErr != nil {
		count++
	}
	if count > 1 {
		return fmt.Errorf("SimpleService_SillyNoop_Result should have at most one field: got %v fields", count)
	}

	return nil
}

// String returns a readable string representation of a SimpleService_SillyNoop_Result
// struct.
func (v *SimpleService_SillyNoop_Result) String() string {
	if v == nil {
		return "<nil>"
	}

	var fields [2]string
	i := 0
	if v.AuthErr != nil {
		fields[i] = fmt.Sprintf("AuthErr: %v", v.AuthErr)
		i++
	}
	if v.ServerErr != nil {
		fields[i] = fmt.Sprintf("ServerErr: %v", v.ServerErr)
		i++
	}

	return fmt.Sprintf("SimpleService_SillyNoop_Result{%v}", strings.Join(fields[:i], ", "))
}

// Equals returns true if all the fields of this SimpleService_SillyNoop_Result match the
// provided SimpleService_SillyNoop_Result.
//
// This function performs a deep comparison.
func (v *SimpleService_SillyNoop_Result) Equals(rhs *SimpleService_SillyNoop_Result) bool {
	if v == nil {
		return rhs == nil
	} else if rhs == nil {
		return false
	}
	if !((v.AuthErr == nil && rhs.AuthErr == nil) || (v.AuthErr != nil && rhs.AuthErr != nil && v.AuthErr.Equals(rhs.AuthErr))) {
		return false
	}
	if !((v.ServerErr == nil && rhs.ServerErr == nil) || (v.ServerErr != nil && rhs.ServerErr != nil && v.ServerErr.Equals(rhs.ServerErr))) {
		return false
	}

	return true
}

// MarshalLogObject implements zapcore.ObjectMarshaler, enabling
// fast logging of SimpleService_SillyNoop_Result.
func (v *SimpleService_SillyNoop_Result) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
	if v == nil {
		return nil
	}
	if v.AuthErr != nil {
		err = multierr.Append(err, enc.AddObject("authErr", v.AuthErr))
	}
	if v.ServerErr != nil {
		err = multierr.Append(err, enc.AddObject("serverErr", v.ServerErr))
	}
	return err
}

// GetAuthErr returns the value of AuthErr if it is set or its
// zero value if it is unset.
func (v *SimpleService_SillyNoop_Result) GetAuthErr() (o *AuthErr) {
	if v != nil && v.AuthErr != nil {
		return v.AuthErr
	}

	return
}

// IsSetAuthErr returns true if AuthErr is not nil.
func (v *SimpleService_SillyNoop_Result) IsSetAuthErr() bool {
	return v != nil && v.AuthErr != nil
}

// GetServerErr returns the value of ServerErr if it is set or its
// zero value if it is unset.
func (v *SimpleService_SillyNoop_Result) GetServerErr() (o *ServerErr) {
	if v != nil && v.ServerErr != nil {
		return v.ServerErr
	}

	return
}

// IsSetServerErr returns true if ServerErr is not nil.
func (v *SimpleService_SillyNoop_Result) IsSetServerErr() bool {
	return v != nil && v.ServerErr != nil
}

// MethodName returns the name of the Thrift function as specified in
// the IDL, for which this struct represent the result.
//
// This will always be "sillyNoop" for this struct.
func (v *SimpleService_SillyNoop_Result) MethodName() string {
	return "sillyNoop"
}

// EnvelopeType returns the kind of value inside this struct.
//
// This will always be Reply for this struct.
func (v *SimpleService_SillyNoop_Result) EnvelopeType() wire.EnvelopeType {
	return wire.Reply
}

// SimpleService_TestUuid_Args represents the arguments for the SimpleService.testUuid function.
//
// The arguments for testUuid are sent and received over the wire as this struct.
type SimpleService_TestUuid_Args struct {
}

// ToWire translates a SimpleService_TestUuid_Args struct into a Thrift-level intermediate
// representation. This intermediate representation may be serialized
// into bytes using a ThriftRW protocol implementation.
//
// An error is returned if the struct or any of its fields failed to
// validate.
//
//	x, err := v.ToWire()
//	if err != nil {
//	  return err
//	}
//
//	if err := binaryProtocol.Encode(x, writer); err != nil {
//	  return err
//	}
func (v *SimpleService_TestUuid_Args) ToWire() (wire.Value, error) {
	var (
		fields [0]wire.Field
		i      int = 0
	)

	return wire.NewValueStruct(wire.Struct{Fields: fields[:i]}), nil
}

// FromWire deserializes a SimpleService_TestUuid_Args struct from its Thrift-level
// representation. The Thrift-level representation may be obtained
// from a ThriftRW protocol implementation.
//
// An error is returned if we were unable to build a SimpleService_TestUuid_Args struct
// from the provided intermediate representation.
//
//	x, err := binaryProtocol.Decode(reader, wire.TStruct)
//	if err != nil {
//	  return nil, err
//	}
//
//	var v SimpleService_TestUuid_Args
//	if err := v.FromWire(x); err != nil {
//	  return nil, err
//	}
//	return &v, nil
func (v *SimpleService_TestUuid_Args) FromWire(w wire.Value) error {

	for _, field := range w.GetStruct().Fields {
		switch field.ID {
		}
	}

	return nil
}

// Encode serializes a SimpleService_TestUuid_Args struct directly into bytes, without going
// through an intermediary type.
//
// An error is returned if a SimpleService_TestUuid_Args struct could not be encoded.
func (v *SimpleService_TestUuid_Args) Encode(sw stream.Writer) error {
	if err := sw.WriteStructBegin(); err != nil {
		return err
	}

	return sw.WriteStructEnd()
}

// Decode deserializes a SimpleService_TestUuid_Args struct directly from its Thrift-level
// representation, without going through an intemediary type.
//
// An error is returned if a SimpleService_TestUuid_Args struct could not be generated from the wire
// representation.
func (v *SimpleService_TestUuid_Args) Decode(sr stream.Reader) error {

	if err := sr.ReadStructBegin(); err != nil {
		return err
	}

	fh, ok, err := sr.ReadFieldBegin()
	if err != nil {
		return err
	}

	for ok {
		switch {
		default:
			if err := sr.Skip(fh.Type); err != nil {
				return err
			}
		}

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

		if fh, ok, err = sr.ReadFieldBegin(); err != nil {
			return err
		}
	}

	if err := sr.ReadStructEnd(); err != nil {
		return err
	}

	return nil
}

// String returns a readable string representation of a SimpleService_TestUuid_Args
// struct.
func (v *SimpleService_TestUuid_Args) String() string {
	if v == nil {
		return "<nil>"
	}

	var fields [0]string
	i := 0

	return fmt.Sprintf("SimpleService_TestUuid_Args{%v}", strings.Join(fields[:i], ", "))
}

// Equals returns true if all the fields of this SimpleService_TestUuid_Args match the
// provided SimpleService_TestUuid_Args.
//
// This function performs a deep comparison.
func (v *SimpleService_TestUuid_Args) Equals(rhs *SimpleService_TestUuid_Args) bool {
	if v == nil {
		return rhs == nil
	} else if rhs == nil {
		return false
	}

	return true
}

// MarshalLogObject implements zapcore.ObjectMarshaler, enabling
// fast logging of SimpleService_TestUuid_Args.
func (v *SimpleService_TestUuid_Args) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
	if v == nil {
		return nil
	}
	return err
}

// MethodName returns the name of the Thrift function as specified in
// the IDL, for which this struct represent the arguments.
//
// This will always be "testUuid" for this struct.
func (v *SimpleService_TestUuid_Args) MethodName() string {
	return "testUuid"
}

// EnvelopeType returns the kind of value inside this struct.
//
// This will always be Call for this struct.
func (v *SimpleService_TestUuid_Args) EnvelopeType() wire.EnvelopeType {
	return wire.Call
}

// SimpleService_TestUuid_Helper provides functions that aid in handling the
// parameters and return values of the SimpleService.testUuid
// function.
var SimpleService_TestUuid_Helper = struct {
	// Args accepts the parameters of testUuid in-order and returns
	// the arguments struct for the function.
	Args func() *SimpleService_TestUuid_Args

	// IsException returns true if the given error can be thrown
	// by testUuid.
	//
	// An error can be thrown by testUuid only if the
	// corresponding exception type was mentioned in the 'throws'
	// section for it in the Thrift file.
	IsException func(error) bool

	// WrapResponse returns the result struct for testUuid
	// given the error returned by it. The provided error may
	// be nil if testUuid did not fail.
	//
	// This allows mapping errors returned by testUuid into a
	// serializable result struct. WrapResponse returns a
	// non-nil error if the provided error cannot be thrown by
	// testUuid
	//
	//   err := testUuid(args)
	//   result, err := SimpleService_TestUuid_Helper.WrapResponse(err)
	//   if err != nil {
	//     return fmt.Errorf("unexpected error from testUuid: %v", err)
	//   }
	//   serialize(result)
	WrapResponse func(error) (*SimpleService_TestUuid_Result, error)

	// UnwrapResponse takes the result struct for testUuid
	// and returns the erorr returned by it (if any).
	//
	// The error is non-nil only if testUuid threw an
	// exception.
	//
	//   result := deserialize(bytes)
	//   err := SimpleService_TestUuid_Helper.UnwrapResponse(result)
	UnwrapResponse func(*SimpleService_TestUuid_Result) error
}{}

func init() {
	SimpleService_TestUuid_Helper.Args = func() *SimpleService_TestUuid_Args {
		return &SimpleService_TestUuid_Args{}
	}

	SimpleService_TestUuid_Helper.IsException = func(err error) bool {
		switch err.(type) {
		default:
			return false
		}
	}

	SimpleService_TestUuid_Helper.WrapResponse = func(err error) (*SimpleService_TestUuid_Result, error) {
		if err == nil {
			return &SimpleService_TestUuid_Result{}, nil
		}

		return nil, err
	}
	SimpleService_TestUuid_Helper.UnwrapResponse = func(result *SimpleService_TestUuid_Result) (err error) {
		return
	}

}

// SimpleService_TestUuid_Result represents the result of a SimpleService.testUuid function call.
//
// The result of a testUuid execution is sent and received over the wire as this struct.
type SimpleService_TestUuid_Result struct {
}

// ToWire translates a SimpleService_TestUuid_Result struct into a Thrift-level intermediate
// representation. This intermediate representation may be serialized
// into bytes using a ThriftRW protocol implementation.
//
// An error is returned if the struct or any of its fields failed to
// validate.
//
//	x, err := v.ToWire()
//	if err != nil {
//	  return err
//	}
//
//	if err := binaryProtocol.Encode(x, writer); err != nil {
//	  return err
//	}
func (v *SimpleService_TestUuid_Result) ToWire() (wire.Value, error) {
	var (
		fields [0]wire.Field
		i      int = 0
	)

	return wire.NewValueStruct(wire.Struct{Fields: fields[:i]}), nil
}

// FromWire deserializes a SimpleService_TestUuid_Result struct from its Thrift-level
// representation. The Thrift-level representation may be obtained
// from a ThriftRW protocol implementation.
//
// An error is returned if we were unable to build a SimpleService_TestUuid_Result struct
// from the provided intermediate representation.
//
//	x, err := binaryProtocol.Decode(reader, wire.TStruct)
//	if err != nil {
//	  return nil, err
//	}
//
//	var v SimpleService_TestUuid_Result
//	if err := v.FromWire(x); err != nil {
//	  return nil, err
//	}
//	return &v, nil
func (v *SimpleService_TestUuid_Result) FromWire(w wire.Value) error {

	for _, field := range w.GetStruct().Fields {
		switch field.ID {
		}
	}

	return nil
}

// Encode serializes a SimpleService_TestUuid_Result struct directly into bytes, without going
// through an intermediary type.
//
// An error is returned if a SimpleService_TestUuid_Result struct could not be encoded.
func (v *SimpleService_TestUuid_Result) Encode(sw stream.Writer) error {
	if err := sw.WriteStructBegin(); err != nil {
		return err
	}

	return sw.WriteStructEnd()
}

// Decode deserializes a SimpleService_TestUuid_Result struct directly from its Thrift-level
// representation, without going through an intemediary type.
//
// An error is returned if a SimpleService_TestUuid_Result struct could not be generated from the wire
// representation.
func (v *SimpleService_TestUuid_Result) Decode(sr stream.Reader) error {

	if err := sr.ReadStructBegin(); err != nil {
		return err
	}

	fh, ok, err := sr.ReadFieldBegin()
	if err != nil {
		return err
	}

	for ok {
		switch {
		default:
			if err := sr.Skip(fh.Type); err != nil {
				return err
			}
		}

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

		if fh, ok, err = sr.ReadFieldBegin(); err != nil {
			return err
		}
	}

	if err := sr.ReadStructEnd(); err != nil {
		return err
	}

	return nil
}

// String returns a readable string representation of a SimpleService_TestUuid_Result
// struct.
func (v *SimpleService_TestUuid_Result) String() string {
	if v == nil {
		return "<nil>"
	}

	var fields [0]string
	i := 0

	return fmt.Sprintf("SimpleService_TestUuid_Result{%v}", strings.Join(fields[:i], ", "))
}

// Equals returns true if all the fields of this SimpleService_TestUuid_Result match the
// provided SimpleService_TestUuid_Result.
//
// This function performs a deep comparison.
func (v *SimpleService_TestUuid_Result) Equals(rhs *SimpleService_TestUuid_Result) bool {
	if v == nil {
		return rhs == nil
	} else if rhs == nil {
		return false
	}

	return true
}

// MarshalLogObject implements zapcore.ObjectMarshaler, enabling
// fast logging of SimpleService_TestUuid_Result.
func (v *SimpleService_TestUuid_Result) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
	if v == nil {
		return nil
	}
	return err
}

// MethodName returns the name of the Thrift function as specified in
// the IDL, for which this struct represent the result.
//
// This will always be "testUuid" for this struct.
func (v *SimpleService_TestUuid_Result) MethodName() string {
	return "testUuid"
}

// EnvelopeType returns the kind of value inside this struct.
//
// This will always be Reply for this struct.
func (v *SimpleService_TestUuid_Result) EnvelopeType() wire.EnvelopeType {
	return wire.Reply
}

// SimpleService_Trans_Args represents the arguments for the SimpleService.trans function.
//
// The arguments for trans are sent and received over the wire as this struct.
type SimpleService_Trans_Args struct {
	Arg1 *TransStruct `json:"arg1,required"`
	Arg2 *TransStruct `json:"arg2,omitempty"`
}

// ToWire translates a SimpleService_Trans_Args struct into a Thrift-level intermediate
// representation. This intermediate representation may be serialized
// into bytes using a ThriftRW protocol implementation.
//
// An error is returned if the struct or any of its fields failed to
// validate.
//
//	x, err := v.ToWire()
//	if err != nil {
//	  return err
//	}
//
//	if err := binaryProtocol.Encode(x, writer); err != nil {
//	  return err
//	}
func (v *SimpleService_Trans_Args) ToWire() (wire.Value, error) {
	var (
		fields [2]wire.Field
		i      int = 0
		w      wire.Value
		err    error
	)

	if v.Arg1 == nil {
		return w, errors.New("field Arg1 of SimpleService_Trans_Args is required")
	}
	w, err = v.Arg1.ToWire()
	if err != nil {
		return w, err
	}
	fields[i] = wire.Field{ID: 1, Value: w}
	i++
	if v.Arg2 != nil {
		w, err = v.Arg2.ToWire()
		if err != nil {
			return w, err
		}
		fields[i] = wire.Field{ID: 2, Value: w}
		i++
	}

	return wire.NewValueStruct(wire.Struct{Fields: fields[:i]}), nil
}

func _TransStruct_Read(w wire.Value) (*TransStruct, error) {
	var v TransStruct
	err := v.FromWire(w)
	return &v, err
}

// FromWire deserializes a SimpleService_Trans_Args struct from its Thrift-level
// representation. The Thrift-level representation may be obtained
// from a ThriftRW protocol implementation.
//
// An error is returned if we were unable to build a SimpleService_Trans_Args struct
// from the provided intermediate representation.
//
//	x, err := binaryProtocol.Decode(reader, wire.TStruct)
//	if err != nil {
//	  return nil, err
//	}
//
//	var v SimpleService_Trans_Args
//	if err := v.FromWire(x); err != nil {
//	  return nil, err
//	}
//	return &v, nil
func (v *SimpleService_Trans_Args) FromWire(w wire.Value) error {
	var err error

	arg1IsSet := false

	for _, field := range w.GetStruct().Fields {
		switch field.ID {
		case 1:
			if field.Value.Type() == wire.TStruct {
				v.Arg1, err = _TransStruct_Read(field.Value)
				if err != nil {
					return err
				}
				arg1IsSet = true
			}
		case 2:
			if field.Value.Type() == wire.TStruct {
				v.Arg2, err = _TransStruct_Read(field.Value)
				if err != nil {
					return err
				}

			}
		}
	}

	if !arg1IsSet {
		return errors.New("field Arg1 of SimpleService_Trans_Args is required")
	}

	return nil
}

// Encode serializes a SimpleService_Trans_Args struct directly into bytes, without going
// through an intermediary type.
//
// An error is returned if a SimpleService_Trans_Args struct could not be encoded.
func (v *SimpleService_Trans_Args) Encode(sw stream.Writer) error {
	if err := sw.WriteStructBegin(); err != nil {
		return err
	}

	if v.Arg1 == nil {
		return errors.New("field Arg1 of SimpleService_Trans_Args is required")
	}
	if err := sw.WriteFieldBegin(stream.FieldHeader{ID: 1, Type: wire.TStruct}); err != nil {
		return err
	}
	if err := v.Arg1.Encode(sw); err != nil {
		return err
	}
	if err := sw.WriteFieldEnd(); err != nil {
		return err
	}

	if v.Arg2 != nil {
		if err := sw.WriteFieldBegin(stream.FieldHeader{ID: 2, Type: wire.TStruct}); err != nil {
			return err
		}
		if err := v.Arg2.Encode(sw); err != nil {
			return err
		}
		if err := sw.WriteFieldEnd(); err != nil {
			return err
		}
	}

	return sw.WriteStructEnd()
}

func _TransStruct_Decode(sr stream.Reader) (*TransStruct, error) {
	var v TransStruct
	err := v.Decode(sr)
	return &v, err
}

// Decode deserializes a SimpleService_Trans_Args struct directly from its Thrift-level
// representation, without going through an intemediary type.
//
// An error is returned if a SimpleService_Trans_Args struct could not be generated from the wire
// representation.
func (v *SimpleService_Trans_Args) Decode(sr stream.Reader) error {

	arg1IsSet := false

	if err := sr.ReadStructBegin(); err != nil {
		return err
	}

	fh, ok, err := sr.ReadFieldBegin()
	if err != nil {
		return err
	}

	for ok {
		switch {
		case fh.ID == 1 && fh.Type == wire.TStruct:
			v.Arg1, err = _TransStruct_Decode(sr)
			if err != nil {
				return err
			}
			arg1IsSet = true
		case fh.ID == 2 && fh.Type == wire.TStruct:
			v.Arg2, err = _TransStruct_Decode(sr)
			if err != nil {
				return err
			}

		default:
			if err := sr.Skip(fh.Type); err != nil {
				return err
			}
		}

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

		if fh, ok, err = sr.ReadFieldBegin(); err != nil {
			return err
		}
	}

	if err := sr.ReadStructEnd(); err != nil {
		return err
	}

	if !arg1IsSet {
		return errors.New("field Arg1 of SimpleService_Trans_Args is required")
	}

	return nil
}

// String returns a readable string representation of a SimpleService_Trans_Args
// struct.
func (v *SimpleService_Trans_Args) String() string {
	if v == nil {
		return "<nil>"
	}

	var fields [2]string
	i := 0
	fields[i] = fmt.Sprintf("Arg1: %v", v.Arg1)
	i++
	if v.Arg2 != nil {
		fields[i] = fmt.Sprintf("Arg2: %v", v.Arg2)
		i++
	}

	return fmt.Sprintf("SimpleService_Trans_Args{%v}", strings.Join(fields[:i], ", "))
}

// Equals returns true if all the fields of this SimpleService_Trans_Args match the
// provided SimpleService_Trans_Args.
//
// This function performs a deep comparison.
func (v *SimpleService_Trans_Args) Equals(rhs *SimpleService_Trans_Args) bool {
	if v == nil {
		return rhs == nil
	} else if rhs == nil {
		return false
	}
	if !v.Arg1.Equals(rhs.Arg1) {
		return false
	}
	if !((v.Arg2 == nil && rhs.Arg2 == nil) || (v.Arg2 != nil && rhs.Arg2 != nil && v.Arg2.Equals(rhs.Arg2))) {
		return false
	}

	return true
}

// MarshalLogObject implements zapcore.ObjectMarshaler, enabling
// fast logging of SimpleService_Trans_Args.
func (v *SimpleService_Trans_Args) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
	if v == nil {
		return nil
	}
	err = multierr.Append(err, enc.AddObject("arg1", v.Arg1))
	if v.Arg2 != nil {
		err = multierr.Append(err, enc.AddObject("arg2", v.Arg2))
	}
	return err
}

// GetArg1 returns the value of Arg1 if it is set or its
// zero value if it is unset.
func (v *SimpleService_Trans_Args) GetArg1() (o *TransStruct) {
	if v != nil {
		o = v.Arg1
	}
	return
}

// IsSetArg1 returns true if Arg1 is not nil.
func (v *SimpleService_Trans_Args) IsSetArg1() bool {
	return v != nil && v.Arg1 != nil
}

// GetArg2 returns the value of Arg2 if it is set or its
// zero value if it is unset.
func (v *SimpleService_Trans_Args) GetArg2() (o *TransStruct) {
	if v != nil && v.Arg2 != nil {
		return v.Arg2
	}

	return
}

// IsSetArg2 returns true if Arg2 is not nil.
func (v *SimpleService_Trans_Args) IsSetArg2() bool {
	return v != nil && v.Arg2 != nil
}

// MethodName returns the name of the Thrift function as specified in
// the IDL, for which this struct represent the arguments.
//
// This will always be "trans" for this struct.
func (v *SimpleService_Trans_Args) MethodName() string {
	return "trans"
}

// EnvelopeType returns the kind of value inside this struct.
//
// This will always be Call for this struct.
func (v *SimpleService_Trans_Args) EnvelopeType() wire.EnvelopeType {
	return wire.Call
}

// SimpleService_Trans_Helper provides functions that aid in handling the
// parameters and return values of the SimpleService.trans
// function.
var SimpleService_Trans_Helper = struct {
	// Args accepts the parameters of trans in-order and returns
	// the arguments struct for the function.
	Args func(
		arg1 *TransStruct,
		arg2 *TransStruct,
	) *SimpleService_Trans_Args

	// IsException returns true if the given error can be thrown
	// by trans.
	//
	// An error can be thrown by trans only if the
	// corresponding exception type was mentioned in the 'throws'
	// section for it in the Thrift file.
	IsException func(error) bool

	// WrapResponse returns the result struct for trans
	// given its return value and error.
	//
	// This allows mapping values and errors returned by
	// trans into a serializable result struct.
	// WrapResponse returns a non-nil error if the provided
	// error cannot be thrown by trans
	//
	//   value, err := trans(args)
	//   result, err := SimpleService_Trans_Helper.WrapResponse(value, err)
	//   if err != nil {
	//     return fmt.Errorf("unexpected error from trans: %v", err)
	//   }
	//   serialize(result)
	WrapResponse func(*TransStruct, error) (*SimpleService_Trans_Result, error)

	// UnwrapResponse takes the result struct for trans
	// and returns the value or error returned by it.
	//
	// The error is non-nil only if trans threw an
	// exception.
	//
	//   result := deserialize(bytes)
	//   value, err := SimpleService_Trans_Helper.UnwrapResponse(result)
	UnwrapResponse func(*SimpleService_Trans_Result) (*TransStruct, error)
}{}

func init() {
	SimpleService_Trans_Helper.Args = func(
		arg1 *TransStruct,
		arg2 *TransStruct,
	) *SimpleService_Trans_Args {
		return &SimpleService_Trans_Args{
			Arg1: arg1,
			Arg2: arg2,
		}
	}

	SimpleService_Trans_Helper.IsException = func(err error) bool {
		switch err.(type) {
		case *AuthErr:
			return true
		case *OtherAuthErr:
			return true
		default:
			return false
		}
	}

	SimpleService_Trans_Helper.WrapResponse = func(success *TransStruct, err error) (*SimpleService_Trans_Result, error) {
		if err == nil {
			return &SimpleService_Trans_Result{Success: success}, nil
		}

		switch e := err.(type) {
		case *AuthErr:
			if e == nil {
				return nil, errors.New("WrapResponse received non-nil error type with nil value for SimpleService_Trans_Result.AuthErr")
			}
			return &SimpleService_Trans_Result{AuthErr: e}, nil
		case *OtherAuthErr:
			if e == nil {
				return nil, errors.New("WrapResponse received non-nil error type with nil value for SimpleService_Trans_Result.OtherAuthErr")
			}
			return &SimpleService_Trans_Result{OtherAuthErr: e}, nil
		}

		return nil, err
	}
	SimpleService_Trans_Helper.UnwrapResponse = func(result *SimpleService_Trans_Result) (success *TransStruct, err error) {
		if result.AuthErr != nil {
			err = result.AuthErr
			return
		}
		if result.OtherAuthErr != nil {
			err = result.OtherAuthErr
			return
		}

		if result.Success != nil {
			success = result.Success
			return
		}

		err = errors.New("expected a non-void result")
		return
	}

}

// SimpleService_Trans_Result represents the result of a SimpleService.trans function call.
//
// The result of a trans execution is sent and received over the wire as this struct.
//
// Success is set only if the function did not throw an exception.
type SimpleService_Trans_Result struct {
	// Value returned by trans after a successful execution.
	Success      *TransStruct  `json:"success,omitempty"`
	AuthErr      *AuthErr      `json:"authErr,omitempty"`
	OtherAuthErr *OtherAuthErr `json:"otherAuthErr,omitempty"`
}

// ToWire translates a SimpleService_Trans_Result struct into a Thrift-level intermediate
// representation. This intermediate representation may be serialized
// into bytes using a ThriftRW protocol implementation.
//
// An error is returned if the struct or any of its fields failed to
// validate.
//
//	x, err := v.ToWire()
//	if err != nil {
//	  return err
//	}
//
//	if err := binaryProtocol.Encode(x, writer); err != nil {
//	  return err
//	}
func (v *SimpleService_Trans_Result) ToWire() (wire.Value, error) {
	var (
		fields [3]wire.Field
		i      int = 0
		w      wire.Value
		err    error
	)

	if v.Success != nil {
		w, err = v.Success.ToWire()
		if err != nil {
			return w, err
		}
		fields[i] = wire.Field{ID: 0, Value: w}
		i++
	}
	if v.AuthErr != nil {
		w, err = v.AuthErr.ToWire()
		if err != nil {
			return w, err
		}
		fields[i] = wire.Field{ID: 1, Value: w}
		i++
	}
	if v.OtherAuthErr != nil {
		w, err = v.OtherAuthErr.ToWire()
		if err != nil {
			return w, err
		}
		fields[i] = wire.Field{ID: 2, Value: w}
		i++
	}

	if i != 1 {
		return wire.Value{}, fmt.Errorf("SimpleService_Trans_Result should have exactly one field: got %v fields", i)
	}

	return wire.NewValueStruct(wire.Struct{Fields: fields[:i]}), nil
}

// FromWire deserializes a SimpleService_Trans_Result struct from its Thrift-level
// representation. The Thrift-level representation may be obtained
// from a ThriftRW protocol implementation.
//
// An error is returned if we were unable to build a SimpleService_Trans_Result struct
// from the provided intermediate representation.
//
//	x, err := binaryProtocol.Decode(reader, wire.TStruct)
//	if err != nil {
//	  return nil, err
//	}
//
//	var v SimpleService_Trans_Result
//	if err := v.FromWire(x); err != nil {
//	  return nil, err
//	}
//	return &v, nil
func (v *SimpleService_Trans_Result) FromWire(w wire.Value) error {
	var err error

	for _, field := range w.GetStruct().Fields {
		switch field.ID {
		case 0:
			if field.Value.Type() == wire.TStruct {
				v.Success, err = _TransStruct_Read(field.Value)
				if err != nil {
					return err
				}

			}
		case 1:
			if field.Value.Type() == wire.TStruct {
				v.AuthErr, err = _AuthErr_Read(field.Value)
				if err != nil {
					return err
				}

			}
		case 2:
			if field.Value.Type() == wire.TStruct {
				v.OtherAuthErr, err = _OtherAuthErr_Read(field.Value)
				if err != nil {
					return err
				}

			}
		}
	}

	count := 0
	if v.Success != nil {
		count++
	}
	if v.AuthErr != nil {
		count++
	}
	if v.OtherAuthErr != nil {
		count++
	}
	if count != 1 {
		return fmt.Errorf("SimpleService_Trans_Result should have exactly one field: got %v fields", count)
	}

	return nil
}

// Encode serializes a SimpleService_Trans_Result struct directly into bytes, without going
// through an intermediary type.
//
// An error is returned if a SimpleService_Trans_Result struct could not be encoded.
func (v *SimpleService_Trans_Result) Encode(sw stream.Writer) error {
	if err := sw.WriteStructBegin(); err != nil {
		return err
	}

	if v.Success != nil {
		if err := sw.WriteFieldBegin(stream.FieldHeader{ID: 0, Type: wire.TStruct}); err != nil {
			return err
		}
		if err := v.Success.Encode(sw); err != nil {
			return err
		}
		if err := sw.WriteFieldEnd(); err != nil {
			return err
		}
	}

	if v.AuthErr != nil {
		if err := sw.WriteFieldBegin(stream.FieldHeader{ID: 1, Type: wire.TStruct}); err != nil {
			return err
		}
		if err := v.AuthErr.Encode(sw); err != nil {
			return err
		}
		if err := sw.WriteFieldEnd(); err != nil {
			return err
		}
	}

	if v.OtherAuthErr != nil {
		if err := sw.WriteFieldBegin(stream.FieldHeader{ID: 2, Type: wire.TStruct}); err != nil {
			return err
		}
		if err := v.OtherAuthErr.Encode(sw); err != nil {
			return err
		}
		if err := sw.WriteFieldEnd(); err != nil {
			return err
		}
	}

	count := 0
	if v.Success != nil {
		count++
	}
	if v.AuthErr != nil {
		count++
	}
	if v.OtherAuthErr != nil {
		count++
	}

	if count != 1 {
		return fmt.Errorf("SimpleService_Trans_Result should have exactly one field: got %v fields", count)
	}

	return sw.WriteStructEnd()
}

// Decode deserializes a SimpleService_Trans_Result struct directly from its Thrift-level
// representation, without going through an intemediary type.
//
// An error is returned if a SimpleService_Trans_Result struct could not be generated from the wire
// representation.
func (v *SimpleService_Trans_Result) Decode(sr stream.Reader) error {

	if err := sr.ReadStructBegin(); err != nil {
		return err
	}

	fh, ok, err := sr.ReadFieldBegin()
	if err != nil {
		return err
	}

	for ok {
		switch {
		case fh.ID == 0 && fh.Type == wire.TStruct:
			v.Success, err = _TransStruct_Decode(sr)
			if err != nil {
				return err
			}

		case fh.ID == 1 && fh.Type == wire.TStruct:
			v.AuthErr, err = _AuthErr_Decode(sr)
			if err != nil {
				return err
			}

		case fh.ID == 2 && fh.Type == wire.TStruct:
			v.OtherAuthErr, err = _OtherAuthErr_Decode(sr)
			if err != nil {
				return err
			}

		default:
			if err := sr.Skip(fh.Type); err != nil {
				return err
			}
		}

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

		if fh, ok, err = sr.ReadFieldBegin(); err != nil {
			return err
		}
	}

	if err := sr.ReadStructEnd(); err != nil {
		return err
	}

	count := 0
	if v.Success != nil {
		count++
	}
	if v.AuthErr != nil {
		count++
	}
	if v.OtherAuthErr != nil {
		count++
	}
	if count != 1 {
		return fmt.Errorf("SimpleService_Trans_Result should have exactly one field: got %v fields", count)
	}

	return nil
}

// String returns a readable string representation of a SimpleService_Trans_Result
// struct.
func (v *SimpleService_Trans_Result) String() string {
	if v == nil {
		return "<nil>"
	}

	var fields [3]string
	i := 0
	if v.Success != nil {
		fields[i] = fmt.Sprintf("Success: %v", v.Success)
		i++
	}
	if v.AuthErr != nil {
		fields[i] = fmt.Sprintf("AuthErr: %v", v.AuthErr)
		i++
	}
	if v.OtherAuthErr != nil {
		fields[i] = fmt.Sprintf("OtherAuthErr: %v", v.OtherAuthErr)
		i++
	}

	return fmt.Sprintf("SimpleService_Trans_Result{%v}", strings.Join(fields[:i], ", "))
}

// Equals returns true if all the fields of this SimpleService_Trans_Result match the
// provided SimpleService_Trans_Result.
//
// This function performs a deep comparison.
func (v *SimpleService_Trans_Result) Equals(rhs *SimpleService_Trans_Result) bool {
	if v == nil {
		return rhs == nil
	} else if rhs == nil {
		return false
	}
	if !((v.Success == nil && rhs.Success == nil) || (v.Success != nil && rhs.Success != nil && v.Success.Equals(rhs.Success))) {
		return false
	}
	if !((v.AuthErr == nil && rhs.AuthErr == nil) || (v.AuthErr != nil && rhs.AuthErr != nil && v.AuthErr.Equals(rhs.AuthErr))) {
		return false
	}
	if !((v.OtherAuthErr == nil && rhs.OtherAuthErr == nil) || (v.OtherAuthErr != nil && rhs.OtherAuthErr != nil && v.OtherAuthErr.Equals(rhs.OtherAuthErr))) {
		return false
	}

	return true
}

// MarshalLogObject implements zapcore.ObjectMarshaler, enabling
// fast logging of SimpleService_Trans_Result.
func (v *SimpleService_Trans_Result) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
	if v == nil {
		return nil
	}
	if v.Success != nil {
		err = multierr.Append(err, enc.AddObject("success", v.Success))
	}
	if v.AuthErr != nil {
		err = multierr.Append(err, enc.AddObject("authErr", v.AuthErr))
	}
	if v.OtherAuthErr != nil {
		err = multierr.Append(err, enc.AddObject("otherAuthErr", v.OtherAuthErr))
	}
	return err
}

// GetSuccess returns the value of Success if it is set or its
// zero value if it is unset.
func (v *SimpleService_Trans_Result) GetSuccess() (o *TransStruct) {
	if v != nil && v.Success != nil {
		return v.Success
	}

	return
}

// IsSetSuccess returns true if Success is not nil.
func (v *SimpleService_Trans_Result) IsSetSuccess() bool {
	return v != nil && v.Success != nil
}

// GetAuthErr returns the value of AuthErr if it is set or its
// zero value if it is unset.
func (v *SimpleService_Trans_Result) GetAuthErr() (o *AuthErr) {
	if v != nil && v.AuthErr != nil {
		return v.AuthErr
	}

	return
}

// IsSetAuthErr returns true if AuthErr is not nil.
func (v *SimpleService_Trans_Result) IsSetAuthErr() bool {
	return v != nil && v.AuthErr != nil
}

// GetOtherAuthErr returns the value of OtherAuthErr if it is set or its
// zero value if it is unset.
func (v *SimpleService_Trans_Result) GetOtherAuthErr() (o *OtherAuthErr) {
	if v != nil && v.OtherAuthErr != nil {
		return v.OtherAuthErr
	}

	return
}

// IsSetOtherAuthErr returns true if OtherAuthErr is not nil.
func (v *SimpleService_Trans_Result) IsSetOtherAuthErr() bool {
	return v != nil && v.OtherAuthErr != nil
}

// MethodName returns the name of the Thrift function as specified in
// the IDL, for which this struct represent the result.
//
// This will always be "trans" for this struct.
func (v *SimpleService_Trans_Result) MethodName() string {
	return "trans"
}

// EnvelopeType returns the kind of value inside this struct.
//
// This will always be Reply for this struct.
func (v *SimpleService_Trans_Result) EnvelopeType() wire.EnvelopeType {
	return wire.Reply
}

// SimpleService_TransHeaders_Args represents the arguments for the SimpleService.transHeaders function.
//
// The arguments for transHeaders are sent and received over the wire as this struct.
type SimpleService_TransHeaders_Args struct {
	Req *TransHeader `json:"req,required"`
}

// ToWire translates a SimpleService_TransHeaders_Args struct into a Thrift-level intermediate
// representation. This intermediate representation may be serialized
// into bytes using a ThriftRW protocol implementation.
//
// An error is returned if the struct or any of its fields failed to
// validate.
//
//	x, err := v.ToWire()
//	if err != nil {
//	  return err
//	}
//
//	if err := binaryProtocol.Encode(x, writer); err != nil {
//	  return err
//	}
func (v *SimpleService_TransHeaders_Args) ToWire() (wire.Value, error) {
	var (
		fields [1]wire.Field
		i      int = 0
		w      wire.Value
		err    error
	)

	if v.Req == nil {
		return w, errors.New("field Req of SimpleService_TransHeaders_Args is required")
	}
	w, err = v.Req.ToWire()
	if err != nil {
		return w, err
	}
	fields[i] = wire.Field{ID: 1, Value: w}
	i++

	return wire.NewValueStruct(wire.Struct{Fields: fields[:i]}), nil
}

func _TransHeader_Read(w wire.Value) (*TransHeader, error) {
	var v TransHeader
	err := v.FromWire(w)
	return &v, err
}

// FromWire deserializes a SimpleService_TransHeaders_Args struct from its Thrift-level
// representation. The Thrift-level representation may be obtained
// from a ThriftRW protocol implementation.
//
// An error is returned if we were unable to build a SimpleService_TransHeaders_Args struct
// from the provided intermediate representation.
//
//	x, err := binaryProtocol.Decode(reader, wire.TStruct)
//	if err != nil {
//	  return nil, err
//	}
//
//	var v SimpleService_TransHeaders_Args
//	if err := v.FromWire(x); err != nil {
//	  return nil, err
//	}
//	return &v, nil
func (v *SimpleService_TransHeaders_Args) FromWire(w wire.Value) error {
	var err error

	reqIsSet := false

	for _, field := range w.GetStruct().Fields {
		switch field.ID {
		case 1:
			if field.Value.Type() == wire.TStruct {
				v.Req, err = _TransHeader_Read(field.Value)
				if err != nil {
					return err
				}
				reqIsSet = true
			}
		}
	}

	if !reqIsSet {
		return errors.New("field Req of SimpleService_TransHeaders_Args is required")
	}

	return nil
}

// Encode serializes a SimpleService_TransHeaders_Args struct directly into bytes, without going
// through an intermediary type.
//
// An error is returned if a SimpleService_TransHeaders_Args struct could not be encoded.
func (v *SimpleService_TransHeaders_Args) Encode(sw stream.Writer) error {
	if err := sw.WriteStructBegin(); err != nil {
		return err
	}

	if v.Req == nil {
		return errors.New("field Req of SimpleService_TransHeaders_Args is required")
	}
	if err := sw.WriteFieldBegin(stream.FieldHeader{ID: 1, Type: wire.TStruct}); err != nil {
		return err
	}
	if err := v.Req.Encode(sw); err != nil {
		return err
	}
	if err := sw.WriteFieldEnd(); err != nil {
		return err
	}

	return sw.WriteStructEnd()
}

func _TransHeader_Decode(sr stream.Reader) (*TransHeader, error) {
	var v TransHeader
	err := v.Decode(sr)
	return &v, err
}

// Decode deserializes a SimpleService_TransHeaders_Args struct directly from its Thrift-level
// representation, without going through an intemediary type.
//
// An error is returned if a SimpleService_TransHeaders_Args struct could not be generated from the wire
// representation.
func (v *SimpleService_TransHeaders_Args) Decode(sr stream.Reader) error {

	reqIsSet := false

	if err := sr.ReadStructBegin(); err != nil {
		return err
	}

	fh, ok, err := sr.ReadFieldBegin()
	if err != nil {
		return err
	}

	for ok {
		switch {
		case fh.ID == 1 && fh.Type == wire.TStruct:
			v.Req, err = _TransHeader_Decode(sr)
			if err != nil {
				return err
			}
			reqIsSet = true
		default:
			if err := sr.Skip(fh.Type); err != nil {
				return err
			}
		}

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

		if fh, ok, err = sr.ReadFieldBegin(); err != nil {
			return err
		}
	}

	if err := sr.ReadStructEnd(); err != nil {
		return err
	}

	if !reqIsSet {
		return errors.New("field Req of SimpleService_TransHeaders_Args is required")
	}

	return nil
}

// String returns a readable string representation of a SimpleService_TransHeaders_Args
// struct.
func (v *SimpleService_TransHeaders_Args) String() string {
	if v == nil {
		return "<nil>"
	}

	var fields [1]string
	i := 0
	fields[i] = fmt.Sprintf("Req: %v", v.Req)
	i++

	return fmt.Sprintf("SimpleService_TransHeaders_Args{%v}", strings.Join(fields[:i], ", "))
}

// Equals returns true if all the fields of this SimpleService_TransHeaders_Args match the
// provided SimpleService_TransHeaders_Args.
//
// This function performs a deep comparison.
func (v *SimpleService_TransHeaders_Args) Equals(rhs *SimpleService_TransHeaders_Args) bool {
	if v == nil {
		return rhs == nil
	} else if rhs == nil {
		return false
	}
	if !v.Req.Equals(rhs.Req) {
		return false
	}

	return true
}

// MarshalLogObject implements zapcore.ObjectMarshaler, enabling
// fast logging of SimpleService_TransHeaders_Args.
func (v *SimpleService_TransHeaders_Args) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
	if v == nil {
		return nil
	}
	err = multierr.Append(err, enc.AddObject("req", v.Req))
	return err
}

// GetReq returns the value of Req if it is set or its
// zero value if it is unset.
func (v *SimpleService_TransHeaders_Args) GetReq() (o *TransHeader) {
	if v != nil {
		o = v.Req
	}
	return
}

// IsSetReq returns true if Req is not nil.
func (v *SimpleService_TransHeaders_Args) IsSetReq() bool {
	return v != nil && v.Req != nil
}

// MethodName returns the name of the Thrift function as specified in
// the IDL, for which this struct represent the arguments.
//
// This will always be "transHeaders" for this struct.
func (v *SimpleService_TransHeaders_Args) MethodName() string {
	return "transHeaders"
}

// EnvelopeType returns the kind of value inside this struct.
//
// This will always be Call for this struct.
func (v *SimpleService_TransHeaders_Args) EnvelopeType() wire.EnvelopeType {
	return wire.Call
}

// SimpleService_TransHeaders_Helper provides functions that aid in handling the
// parameters and return values of the SimpleService.transHeaders
// function.
var SimpleService_TransHeaders_Helper = struct {
	// Args accepts the parameters of transHeaders in-order and returns
	// the arguments struct for the function.
	Args func(
		req *TransHeader,
	) *SimpleService_TransHeaders_Args

	// IsException returns true if the given error can be thrown
	// by transHeaders.
	//
	// An error can be thrown by transHeaders only if the
	// corresponding exception type was mentioned in the 'throws'
	// section for it in the Thrift file.
	IsException func(error) bool

	// WrapResponse returns the result struct for transHeaders
	// given its return value and error.
	//
	// This allows mapping values and errors returned by
	// transHeaders into a serializable result struct.
	// WrapResponse returns a non-nil error if the provided
	// error cannot be thrown by transHeaders
	//
	//   value, err := transHeaders(args)
	//   result, err := SimpleService_TransHeaders_Helper.WrapResponse(value, err)
	//   if err != nil {
	//     return fmt.Errorf("unexpected error from transHeaders: %v", err)
	//   }
	//   serialize(result)
	WrapResponse func(*TransHeader, error) (*SimpleService_TransHeaders_Result, error)

	// UnwrapResponse takes the result struct for transHeaders
	// and returns the value or error returned by it.
	//
	// The error is non-nil only if transHeaders threw an
	// exception.
	//
	//   result := deserialize(bytes)
	//   value, err := SimpleService_TransHeaders_Helper.UnwrapResponse(result)
	UnwrapResponse func(*SimpleService_TransHeaders_Result) (*TransHeader, error)
}{}

func init() {
	SimpleService_TransHeaders_Helper.Args = func(
		req *TransHeader,
	) *SimpleService_TransHeaders_Args {
		return &SimpleService_TransHeaders_Args{
			Req: req,
		}
	}

	SimpleService_TransHeaders_Helper.IsException = func(err error) bool {
		switch err.(type) {
		case *AuthErr:
			return true
		case *OtherAuthErr:
			return true
		default:
			return false
		}
	}

	SimpleService_TransHeaders_Helper.WrapResponse = func(success *TransHeader, err error) (*SimpleService_TransHeaders_Result, error) {
		if err == nil {
			return &SimpleService_TransHeaders_Result{Success: success}, nil
		}

		switch e := err.(type) {
		case *AuthErr:
			if e == nil {
				return nil, errors.New("WrapResponse received non-nil error type with nil value for SimpleService_TransHeaders_Result.AuthErr")
			}
			return &SimpleService_TransHeaders_Result{AuthErr: e}, nil
		case *OtherAuthErr:
			if e == nil {
				return nil, errors.New("WrapResponse received non-nil error type with nil value for SimpleService_TransHeaders_Result.OtherAuthErr")
			}
			return &SimpleService_TransHeaders_Result{OtherAuthErr: e}, nil
		}

		return nil, err
	}
	SimpleService_TransHeaders_Helper.UnwrapResponse = func(result *SimpleService_TransHeaders_Result) (success *TransHeader, err error) {
		if result.AuthErr != nil {
			err = result.AuthErr
			return
		}
		if result.OtherAuthErr != nil {
			err = result.OtherAuthErr
			return
		}

		if result.Success != nil {
			success = result.Success
			return
		}

		err = errors.New("expected a non-void result")
		return
	}

}

// SimpleService_TransHeaders_Result represents the result of a SimpleService.transHeaders function call.
//
// The result of a transHeaders execution is sent and received over the wire as this struct.
//
// Success is set only if the function did not throw an exception.
type SimpleService_TransHeaders_Result struct {
	// Value returned by transHeaders after a successful execution.
	Success      *TransHeader  `json:"success,omitempty"`
	AuthErr      *AuthErr      `json:"authErr,omitempty"`
	OtherAuthErr *OtherAuthErr `json:"otherAuthErr,omitempty"`
}

// ToWire translates a SimpleService_TransHeaders_Result struct into a Thrift-level intermediate
// representation. This intermediate representation may be serialized
// into bytes using a ThriftRW protocol implementation.
//
// An error is returned if the struct or any of its fields failed to
// validate.
//
//	x, err := v.ToWire()
//	if err != nil {
//	  return err
//	}
//
//	if err := binaryProtocol.Encode(x, writer); err != nil {
//	  return err
//	}
func (v *SimpleService_TransHeaders_Result) ToWire() (wire.Value, error) {
	var (
		fields [3]wire.Field
		i      int = 0
		w      wire.Value
		err    error
	)

	if v.Success != nil {
		w, err = v.Success.ToWire()
		if err != nil {
			return w, err
		}
		fields[i] = wire.Field{ID: 0, Value: w}
		i++
	}
	if v.AuthErr != nil {
		w, err = v.AuthErr.ToWire()
		if err != nil {
			return w, err
		}
		fields[i] = wire.Field{ID: 1, Value: w}
		i++
	}
	if v.OtherAuthErr != nil {
		w, err = v.OtherAuthErr.ToWire()
		if err != nil {
			return w, err
		}
		fields[i] = wire.Field{ID: 2, Value: w}
		i++
	}

	if i != 1 {
		return wire.Value{}, fmt.Errorf("SimpleService_TransHeaders_Result should have exactly one field: got %v fields", i)
	}

	return wire.NewValueStruct(wire.Struct{Fields: fields[:i]}), nil
}

// FromWire deserializes a SimpleService_TransHeaders_Result struct from its Thrift-level
// representation. The Thrift-level representation may be obtained
// from a ThriftRW protocol implementation.
//
// An error is returned if we were unable to build a SimpleService_TransHeaders_Result struct
// from the provided intermediate representation.
//
//	x, err := binaryProtocol.Decode(reader, wire.TStruct)
//	if err != nil {
//	  return nil, err
//	}
//
//	var v SimpleService_TransHeaders_Result
//	if err := v.FromWire(x); err != nil {
//	  return nil, err
//	}
//	return &v, nil
func (v *SimpleService_TransHeaders_Result) FromWire(w wire.Value) error {
	var err error

	for _, field := range w.GetStruct().Fields {
		switch field.ID {
		case 0:
			if field.Value.Type() == wire.TStruct {
				v.Success, err = _TransHeader_Read(field.Value)
				if err != nil {
					return err
				}

			}
		case 1:
			if field.Value.Type() == wire.TStruct {
				v.AuthErr, err = _AuthErr_Read(field.Value)
				if err != nil {
					return err
				}

			}
		case 2:
			if field.Value.Type() == wire.TStruct {
				v.OtherAuthErr, err = _OtherAuthErr_Read(field.Value)
				if err != nil {
					return err
				}

			}
		}
	}

	count := 0
	if v.Success != nil {
		count++
	}
	if v.AuthErr != nil {
		count++
	}
	if v.OtherAuthErr != nil {
		count++
	}
	if count != 1 {
		return fmt.Errorf("SimpleService_TransHeaders_Result should have exactly one field: got %v fields", count)
	}

	return nil
}

// Encode serializes a SimpleService_TransHeaders_Result struct directly into bytes, without going
// through an intermediary type.
//
// An error is returned if a SimpleService_TransHeaders_Result struct could not be encoded.
func (v *SimpleService_TransHeaders_Result) Encode(sw stream.Writer) error {
	if err := sw.WriteStructBegin(); err != nil {
		return err
	}

	if v.Success != nil {
		if err := sw.WriteFieldBegin(stream.FieldHeader{ID: 0, Type: wire.TStruct}); err != nil {
			return err
		}
		if err := v.Success.Encode(sw); err != nil {
			return err
		}
		if err := sw.WriteFieldEnd(); err != nil {
			return err
		}
	}

	if v.AuthErr != nil {
		if err := sw.WriteFieldBegin(stream.FieldHeader{ID: 1, Type: wire.TStruct}); err != nil {
			return err
		}
		if err := v.AuthErr.Encode(sw); err != nil {
			return err
		}
		if err := sw.WriteFieldEnd(); err != nil {
			return err
		}
	}

	if v.OtherAuthErr != nil {
		if err := sw.WriteFieldBegin(stream.FieldHeader{ID: 2, Type: wire.TStruct}); err != nil {
			return err
		}
		if err := v.OtherAuthErr.Encode(sw); err != nil {
			return err
		}
		if err := sw.WriteFieldEnd(); err != nil {
			return err
		}
	}

	count := 0
	if v.Success != nil {
		count++
	}
	if v.AuthErr != nil {
		count++
	}
	if v.OtherAuthErr != nil {
		count++
	}

	if count != 1 {
		return fmt.Errorf("SimpleService_TransHeaders_Result should have exactly one field: got %v fields", count)
	}

	return sw.WriteStructEnd()
}

// Decode deserializes a SimpleService_TransHeaders_Result struct directly from its Thrift-level
// representation, without going through an intemediary type.
//
// An error is returned if a SimpleService_TransHeaders_Result struct could not be generated from the wire
// representation.
func (v *SimpleService_TransHeaders_Result) Decode(sr stream.Reader) error {

	if err := sr.ReadStructBegin(); err != nil {
		return err
	}

	fh, ok, err := sr.ReadFieldBegin()
	if err != nil {
		return err
	}

	for ok {
		switch {
		case fh.ID == 0 && fh.Type == wire.TStruct:
			v.Success, err = _TransHeader_Decode(sr)
			if err != nil {
				return err
			}

		case fh.ID == 1 && fh.Type == wire.TStruct:
			v.AuthErr, err = _AuthErr_Decode(sr)
			if err != nil {
				return err
			}

		case fh.ID == 2 && fh.Type == wire.TStruct:
			v.OtherAuthErr, err = _OtherAuthErr_Decode(sr)
			if err != nil {
				return err
			}

		default:
			if err := sr.Skip(fh.Type); err != nil {
				return err
			}
		}

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

		if fh, ok, err = sr.ReadFieldBegin(); err != nil {
			return err
		}
	}

	if err := sr.ReadStructEnd(); err != nil {
		return err
	}

	count := 0
	if v.Success != nil {
		count++
	}
	if v.AuthErr != nil {
		count++
	}
	if v.OtherAuthErr != nil {
		count++
	}
	if count != 1 {
		return fmt.Errorf("SimpleService_TransHeaders_Result should have exactly one field: got %v fields", count)
	}

	return nil
}

// String returns a readable string representation of a SimpleService_TransHeaders_Result
// struct.
func (v *SimpleService_TransHeaders_Result) String() string {
	if v == nil {
		return "<nil>"
	}

	var fields [3]string
	i := 0
	if v.Success != nil {
		fields[i] = fmt.Sprintf("Success: %v", v.Success)
		i++
	}
	if v.AuthErr != nil {
		fields[i] = fmt.Sprintf("AuthErr: %v", v.AuthErr)
		i++
	}
	if v.OtherAuthErr != nil {
		fields[i] = fmt.Sprintf("OtherAuthErr: %v", v.OtherAuthErr)
		i++
	}

	return fmt.Sprintf("SimpleService_TransHeaders_Result{%v}", strings.Join(fields[:i], ", "))
}

// Equals returns true if all the fields of this SimpleService_TransHeaders_Result match the
// provided SimpleService_TransHeaders_Result.
//
// This function performs a deep comparison.
func (v *SimpleService_TransHeaders_Result) Equals(rhs *SimpleService_TransHeaders_Result) bool {
	if v == nil {
		return rhs == nil
	} else if rhs == nil {
		return false
	}
	if !((v.Success == nil && rhs.Success == nil) || (v.Success != nil && rhs.Success != nil && v.Success.Equals(rhs.Success))) {
		return false
	}
	if !((v.AuthErr == nil && rhs.AuthErr == nil) || (v.AuthErr != nil && rhs.AuthErr != nil && v.AuthErr.Equals(rhs.AuthErr))) {
		return false
	}
	if !((v.OtherAuthErr == nil && rhs.OtherAuthErr == nil) || (v.OtherAuthErr != nil && rhs.OtherAuthErr != nil && v.OtherAuthErr.Equals(rhs.OtherAuthErr))) {
		return false
	}

	return true
}

// MarshalLogObject implements zapcore.ObjectMarshaler, enabling
// fast logging of SimpleService_TransHeaders_Result.
func (v *SimpleService_TransHeaders_Result) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
	if v == nil {
		return nil
	}
	if v.Success != nil {
		err = multierr.Append(err, enc.AddObject("success", v.Success))
	}
	if v.AuthErr != nil {
		err = multierr.Append(err, enc.AddObject("authErr", v.AuthErr))
	}
	if v.OtherAuthErr != nil {
		err = multierr.Append(err, enc.AddObject("otherAuthErr", v.OtherAuthErr))
	}
	return err
}

// GetSuccess returns the value of Success if it is set or its
// zero value if it is unset.
func (v *SimpleService_TransHeaders_Result) GetSuccess() (o *TransHeader) {
	if v != nil && v.Success != nil {
		return v.Success
	}

	return
}

// IsSetSuccess returns true if Success is not nil.
func (v *SimpleService_TransHeaders_Result) IsSetSuccess() bool {
	return v != nil && v.Success != nil
}

// GetAuthErr returns the value of AuthErr if it is set or its
// zero value if it is unset.
func (v *SimpleService_TransHeaders_Result) GetAuthErr() (o *AuthErr) {
	if v != nil && v.AuthErr != nil {
		return v.AuthErr
	}

	return
}

// IsSetAuthErr returns true if AuthErr is not nil.
func (v *SimpleService_TransHeaders_Result) IsSetAuthErr() bool {
	return v != nil && v.AuthErr != nil
}

// GetOtherAuthErr returns the value of OtherAuthErr if it is set or its
// zero value if it is unset.
func (v *SimpleService_TransHeaders_Result) GetOtherAuthErr() (o *OtherAuthErr) {
	if v != nil && v.OtherAuthErr != nil {
		return v.OtherAuthErr
	}

	return
}

// IsSetOtherAuthErr returns true if OtherAuthErr is not nil.
func (v *SimpleService_TransHeaders_Result) IsSetOtherAuthErr() bool {
	return v != nil && v.OtherAuthErr != nil
}

// MethodName returns the name of the Thrift function as specified in
// the IDL, for which this struct represent the result.
//
// This will always be "transHeaders" for this struct.
func (v *SimpleService_TransHeaders_Result) MethodName() string {
	return "transHeaders"
}

// EnvelopeType returns the kind of value inside this struct.
//
// This will always be Reply for this struct.
func (v *SimpleService_TransHeaders_Result) EnvelopeType() wire.EnvelopeType {
	return wire.Reply
}

// SimpleService_TransHeadersNoReq_Args represents the arguments for the SimpleService.transHeadersNoReq function.
//
// The arguments for transHeadersNoReq are sent and received over the wire as this struct.
type SimpleService_TransHeadersNoReq_Args struct {
}

// ToWire translates a SimpleService_TransHeadersNoReq_Args struct into a Thrift-level intermediate
// representation. This intermediate representation may be serialized
// into bytes using a ThriftRW protocol implementation.
//
// An error is returned if the struct or any of its fields failed to
// validate.
//
//	x, err := v.ToWire()
//	if err != nil {
//	  return err
//	}
//
//	if err := binaryProtocol.Encode(x, writer); err != nil {
//	  return err
//	}
func (v *SimpleService_TransHeadersNoReq_Args) ToWire() (wire.Value, error) {
	var (
		fields [0]wire.Field
		i      int = 0
	)

	return wire.NewValueStruct(wire.Struct{Fields: fields[:i]}), nil
}

// FromWire deserializes a SimpleService_TransHeadersNoReq_Args struct from its Thrift-level
// representation. The Thrift-level representation may be obtained
// from a ThriftRW protocol implementation.
//
// An error is returned if we were unable to build a SimpleService_TransHeadersNoReq_Args struct
// from the provided intermediate representation.
//
//	x, err := binaryProtocol.Decode(reader, wire.TStruct)
//	if err != nil {
//	  return nil, err
//	}
//
//	var v SimpleService_TransHeadersNoReq_Args
//	if err := v.FromWire(x); err != nil {
//	  return nil, err
//	}
//	return &v, nil
func (v *SimpleService_TransHeadersNoReq_Args) FromWire(w wire.Value) error {

	for _, field := range w.GetStruct().Fields {
		switch field.ID {
		}
	}

	return nil
}

// Encode serializes a SimpleService_TransHeadersNoReq_Args struct directly into bytes, without going
// through an intermediary type.
//
// An error is returned if a SimpleService_TransHeadersNoReq_Args struct could not be encoded.
func (v *SimpleService_TransHeadersNoReq_Args) Encode(sw stream.Writer) error {
	if err := sw.WriteStructBegin(); err != nil {
		return err
	}

	return sw.WriteStructEnd()
}

// Decode deserializes a SimpleService_TransHeadersNoReq_Args struct directly from its Thrift-level
// representation, without going through an intemediary type.
//
// An error is returned if a SimpleService_TransHeadersNoReq_Args struct could not be generated from the wire
// representation.
func (v *SimpleService_TransHeadersNoReq_Args) Decode(sr stream.Reader) error {

	if err := sr.ReadStructBegin(); err != nil {
		return err
	}

	fh, ok, err := sr.ReadFieldBegin()
	if err != nil {
		return err
	}

	for ok {
		switch {
		default:
			if err := sr.Skip(fh.Type); err != nil {
				return err
			}
		}

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

		if fh, ok, err = sr.ReadFieldBegin(); err != nil {
			return err
		}
	}

	if err := sr.ReadStructEnd(); err != nil {
		return err
	}

	return nil
}

// String returns a readable string representation of a SimpleService_TransHeadersNoReq_Args
// struct.
func (v *SimpleService_TransHeadersNoReq_Args) String() string {
	if v == nil {
		return "<nil>"
	}

	var fields [0]string
	i := 0

	return fmt.Sprintf("SimpleService_TransHeadersNoReq_Args{%v}", strings.Join(fields[:i], ", "))
}

// Equals returns true if all the fields of this SimpleService_TransHeadersNoReq_Args match the
// provided SimpleService_TransHeadersNoReq_Args.
//
// This function performs a deep comparison.
func (v *SimpleService_TransHeadersNoReq_Args) Equals(rhs *SimpleService_TransHeadersNoReq_Args) bool {
	if v == nil {
		return rhs == nil
	} else if rhs == nil {
		return false
	}

	return true
}

// MarshalLogObject implements zapcore.ObjectMarshaler, enabling
// fast logging of SimpleService_TransHeadersNoReq_Args.
func (v *SimpleService_TransHeadersNoReq_Args) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
	if v == nil {
		return nil
	}
	return err
}

// MethodName returns the name of the Thrift function as specified in
// the IDL, for which this struct represent the arguments.
//
// This will always be "transHeadersNoReq" for this struct.
func (v *SimpleService_TransHeadersNoReq_Args) MethodName() string {
	return "transHeadersNoReq"
}

// EnvelopeType returns the kind of value inside this struct.
//
// This will always be Call for this struct.
func (v *SimpleService_TransHeadersNoReq_Args) EnvelopeType() wire.EnvelopeType {
	return wire.Call
}

// SimpleService_TransHeadersNoReq_Helper provides functions that aid in handling the
// parameters and return values of the SimpleService.transHeadersNoReq
// function.
var SimpleService_TransHeadersNoReq_Helper = struct {
	// Args accepts the parameters of transHeadersNoReq in-order and returns
	// the arguments struct for the function.
	Args func() *SimpleService_TransHeadersNoReq_Args

	// IsException returns true if the given error can be thrown
	// by transHeadersNoReq.
	//
	// An error can be thrown by transHeadersNoReq only if the
	// corresponding exception type was mentioned in the 'throws'
	// section for it in the Thrift file.
	IsException func(error) bool

	// WrapResponse returns the result struct for transHeadersNoReq
	// given its return value and error.
	//
	// This allows mapping values and errors returned by
	// transHeadersNoReq into a serializable result struct.
	// WrapResponse returns a non-nil error if the provided
	// error cannot be thrown by transHeadersNoReq
	//
	//   value, err := transHeadersNoReq(args)
	//   result, err := SimpleService_TransHeadersNoReq_Helper.WrapResponse(value, err)
	//   if err != nil {
	//     return fmt.Errorf("unexpected error from transHeadersNoReq: %v", err)
	//   }
	//   serialize(result)
	WrapResponse func(*TransHeader, error) (*SimpleService_TransHeadersNoReq_Result, error)

	// UnwrapResponse takes the result struct for transHeadersNoReq
	// and returns the value or error returned by it.
	//
	// The error is non-nil only if transHeadersNoReq threw an
	// exception.
	//
	//   result := deserialize(bytes)
	//   value, err := SimpleService_TransHeadersNoReq_Helper.UnwrapResponse(result)
	UnwrapResponse func(*SimpleService_TransHeadersNoReq_Result) (*TransHeader, error)
}{}

func init() {
	SimpleService_TransHeadersNoReq_Helper.Args = func() *SimpleService_TransHeadersNoReq_Args {
		return &SimpleService_TransHeadersNoReq_Args{}
	}

	SimpleService_TransHeadersNoReq_Helper.IsException = func(err error) bool {
		switch err.(type) {
		case *AuthErr:
			return true
		default:
			return false
		}
	}

	SimpleService_TransHeadersNoReq_Helper.WrapResponse = func(success *TransHeader, err error) (*SimpleService_TransHeadersNoReq_Result, error) {
		if err == nil {
			return &SimpleService_TransHeadersNoReq_Result{Success: success}, nil
		}

		switch e := err.(type) {
		case *AuthErr:
			if e == nil {
				return nil, errors.New("WrapResponse received non-nil error type with nil value for SimpleService_TransHeadersNoReq_Result.AuthErr")
			}
			return &SimpleService_TransHeadersNoReq_Result{AuthErr: e}, nil
		}

		return nil, err
	}
	SimpleService_TransHeadersNoReq_Helper.UnwrapResponse = func(result *SimpleService_TransHeadersNoReq_Result) (success *TransHeader, err error) {
		if result.AuthErr != nil {
			err = result.AuthErr
			return
		}

		if result.Success != nil {
			success = result.Success
			return
		}

		err = errors.New("expected a non-void result")
		return
	}

}

// SimpleService_TransHeadersNoReq_Result represents the result of a SimpleService.transHeadersNoReq function call.
//
// The result of a transHeadersNoReq execution is sent and received over the wire as this struct.
//
// Success is set only if the function did not throw an exception.
type SimpleService_TransHeadersNoReq_Result struct {
	// Value returned by transHeadersNoReq after a successful execution.
	Success *TransHeader `json:"success,omitempty"`
	AuthErr *AuthErr     `json:"authErr,omitempty"`
}

// ToWire translates a SimpleService_TransHeadersNoReq_Result struct into a Thrift-level intermediate
// representation. This intermediate representation may be serialized
// into bytes using a ThriftRW protocol implementation.
//
// An error is returned if the struct or any of its fields failed to
// validate.
//
//	x, err := v.ToWire()
//	if err != nil {
//	  return err
//	}
//
//	if err := binaryProtocol.Encode(x, writer); err != nil {
//	  return err
//	}
func (v *SimpleService_TransHeadersNoReq_Result) ToWire() (wire.Value, error) {
	var (
		fields [2]wire.Field
		i      int = 0
		w      wire.Value
		err    error
	)

	if v.Success != nil {
		w, err = v.Success.ToWire()
		if err != nil {
			return w, err
		}
		fields[i] = wire.Field{ID: 0, Value: w}
		i++
	}
	if v.AuthErr != nil {
		w, err = v.AuthErr.ToWire()
		if err != nil {
			return w, err
		}
		fields[i] = wire.Field{ID: 1, Value: w}
		i++
	}

	if i != 1 {
		return wire.Value{}, fmt.Errorf("SimpleService_TransHeadersNoReq_Result should have exactly one field: got %v fields", i)
	}

	return wire.NewValueStruct(wire.Struct{Fields: fields[:i]}), nil
}

// FromWire deserializes a SimpleService_TransHeadersNoReq_Result struct from its Thrift-level
// representation. The Thrift-level representation may be obtained
// from a ThriftRW protocol implementation.
//
// An error is returned if we were unable to build a SimpleService_TransHeadersNoReq_Result struct
// from the provided intermediate representation.
//
//	x, err := binaryProtocol.Decode(reader, wire.TStruct)
//	if err != nil {
//	  return nil, err
//	}
//
//	var v SimpleService_TransHeadersNoReq_Result
//	if err := v.FromWire(x); err != nil {
//	  return nil, err
//	}
//	return &v, nil
func (v *SimpleService_TransHeadersNoReq_Result) FromWire(w wire.Value) error {
	var err error

	for _, field := range w.GetStruct().Fields {
		switch field.ID {
		case 0:
			if field.Value.Type() == wire.TStruct {
				v.Success, err = _TransHeader_Read(field.Value)
				if err != nil {
					return err
				}

			}
		case 1:
			if field.Value.Type() == wire.TStruct {
				v.AuthErr, err = _AuthErr_Read(field.Value)
				if err != nil {
					return err
				}

			}
		}
	}

	count := 0
	if v.Success != nil {
		count++
	}
	if v.AuthErr != nil {
		count++
	}
	if count != 1 {
		return fmt.Errorf("SimpleService_TransHeadersNoReq_Result should have exactly one field: got %v fields", count)
	}

	return nil
}

// Encode serializes a SimpleService_TransHeadersNoReq_Result struct directly into bytes, without going
// through an intermediary type.
//
// An error is returned if a SimpleService_TransHeadersNoReq_Result struct could not be encoded.
func (v *SimpleService_TransHeadersNoReq_Result) Encode(sw stream.Writer) error {
	if err := sw.WriteStructBegin(); err != nil {
		return err
	}

	if v.Success != nil {
		if err := sw.WriteFieldBegin(stream.FieldHeader{ID: 0, Type: wire.TStruct}); err != nil {
			return err
		}
		if err := v.Success.Encode(sw); err != nil {
			return err
		}
		if err := sw.WriteFieldEnd(); err != nil {
			return err
		}
	}

	if v.AuthErr != nil {
		if err := sw.WriteFieldBegin(stream.FieldHeader{ID: 1, Type: wire.TStruct}); err != nil {
			return err
		}
		if err := v.AuthErr.Encode(sw); err != nil {
			return err
		}
		if err := sw.WriteFieldEnd(); err != nil {
			return err
		}
	}

	count := 0
	if v.Success != nil {
		count++
	}
	if v.AuthErr != nil {
		count++
	}

	if count != 1 {
		return fmt.Errorf("SimpleService_TransHeadersNoReq_Result should have exactly one field: got %v fields", count)
	}

	return sw.WriteStructEnd()
}

// Decode deserializes a SimpleService_TransHeadersNoReq_Result struct directly from its Thrift-level
// representation, without going through an intemediary type.
//
// An error is returned if a SimpleService_TransHeadersNoReq_Result struct could not be generated from the wire
// representation.
func (v *SimpleService_TransHeadersNoReq_Result) Decode(sr stream.Reader) error {

	if err := sr.ReadStructBegin(); err != nil {
		return err
	}

	fh, ok, err := sr.ReadFieldBegin()
	if err != nil {
		return err
	}

	for ok {
		switch {
		case fh.ID == 0 && fh.Type == wire.TStruct:
			v.Success, err = _TransHeader_Decode(sr)
			if err != nil {
				return err
			}

		case fh.ID == 1 && fh.Type == wire.TStruct:
			v.AuthErr, err = _AuthErr_Decode(sr)
			if err != nil {
				return err
			}

		default:
			if err := sr.Skip(fh.Type); err != nil {
				return err
			}
		}

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

		if fh, ok, err = sr.ReadFieldBegin(); err != nil {
			return err
		}
	}

	if err := sr.ReadStructEnd(); err != nil {
		return err
	}

	count := 0
	if v.Success != nil {
		count++
	}
	if v.AuthErr != nil {
		count++
	}
	if count != 1 {
		return fmt.Errorf("SimpleService_TransHeadersNoReq_Result should have exactly one field: got %v fields", count)
	}

	return nil
}

// String returns a readable string representation of a SimpleService_TransHeadersNoReq_Result
// struct.
func (v *SimpleService_TransHeadersNoReq_Result) String() string {
	if v == nil {
		return "<nil>"
	}

	var fields [2]string
	i := 0
	if v.Success != nil {
		fields[i] = fmt.Sprintf("Success: %v", v.Success)
		i++
	}
	if v.AuthErr != nil {
		fields[i] = fmt.Sprintf("AuthErr: %v", v.AuthErr)
		i++
	}

	return fmt.Sprintf("SimpleService_TransHeadersNoReq_Result{%v}", strings.Join(fields[:i], ", "))
}

// Equals returns true if all the fields of this SimpleService_TransHeadersNoReq_Result match the
// provided SimpleService_TransHeadersNoReq_Result.
//
// This function performs a deep comparison.
func (v *SimpleService_TransHeadersNoReq_Result) Equals(rhs *SimpleService_TransHeadersNoReq_Result) bool {
	if v == nil {
		return rhs == nil
	} else if rhs == nil {
		return false
	}
	if !((v.Success == nil && rhs.Success == nil) || (v.Success != nil && rhs.Success != nil && v.Success.Equals(rhs.Success))) {
		return false
	}
	if !((v.AuthErr == nil && rhs.AuthErr == nil) || (v.AuthErr != nil && rhs.AuthErr != nil && v.AuthErr.Equals(rhs.AuthErr))) {
		return false
	}

	return true
}

// MarshalLogObject implements zapcore.ObjectMarshaler, enabling
// fast logging of SimpleService_TransHeadersNoReq_Result.
func (v *SimpleService_TransHeadersNoReq_Result) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
	if v == nil {
		return nil
	}
	if v.Success != nil {
		err = multierr.Append(err, enc.AddObject("success", v.Success))
	}
	if v.AuthErr != nil {
		err = multierr.Append(err, enc.AddObject("authErr", v.AuthErr))
	}
	return err
}

// GetSuccess returns the value of Success if it is set or its
// zero value if it is unset.
func (v *SimpleService_TransHeadersNoReq_Result) GetSuccess() (o *TransHeader) {
	if v != nil && v.Success != nil {
		return v.Success
	}

	return
}

// IsSetSuccess returns true if Success is not nil.
func (v *SimpleService_TransHeadersNoReq_Result) IsSetSuccess() bool {
	return v != nil && v.Success != nil
}

// GetAuthErr returns the value of AuthErr if it is set or its
// zero value if it is unset.
func (v *SimpleService_TransHeadersNoReq_Result) GetAuthErr() (o *AuthErr) {
	if v != nil && v.AuthErr != nil {
		return v.AuthErr
	}

	return
}

// IsSetAuthErr returns true if AuthErr is not nil.
func (v *SimpleService_TransHeadersNoReq_Result) IsSetAuthErr() bool {
	return v != nil && v.AuthErr != nil
}

// MethodName returns the name of the Thrift function as specified in
// the IDL, for which this struct represent the result.
//
// This will always be "transHeadersNoReq" for this struct.
func (v *SimpleService_TransHeadersNoReq_Result) MethodName() string {
	return "transHeadersNoReq"
}

// EnvelopeType returns the kind of value inside this struct.
//
// This will always be Reply for this struct.
func (v *SimpleService_TransHeadersNoReq_Result) EnvelopeType() wire.EnvelopeType {
	return wire.Reply
}

// SimpleService_TransHeadersType_Args represents the arguments for the SimpleService.transHeadersType function.
//
// The arguments for transHeadersType are sent and received over the wire as this struct.
type SimpleService_TransHeadersType_Args struct {
	Req *TransHeader `json:"req,required"`
}

// ToWire translates a SimpleService_TransHeadersType_Args struct into a Thrift-level intermediate
// representation. This intermediate representation may be serialized
// into bytes using a ThriftRW protocol implementation.
//
// An error is returned if the struct or any of its fields failed to
// validate.
//
//	x, err := v.ToWire()
//	if err != nil {
//	  return err
//	}
//
//	if err := binaryProtocol.Encode(x, writer); err != nil {
//	  return err
//	}
func (v *SimpleService_TransHeadersType_Args) ToWire() (wire.Value, error) {
	var (
		fields [1]wire.Field
		i      int = 0
		w      wire.Value
		err    error
	)

	if v.Req == nil {
		return w, errors.New("field Req of SimpleService_TransHeadersType_Args is required")
	}
	w, err = v.Req.ToWire()
	if err != nil {
		return w, err
	}
	fields[i] = wire.Field{ID: 1, Value: w}
	i++

	return wire.NewValueStruct(wire.Struct{Fields: fields[:i]}), nil
}

// FromWire deserializes a SimpleService_TransHeadersType_Args struct from its Thrift-level
// representation. The Thrift-level representation may be obtained
// from a ThriftRW protocol implementation.
//
// An error is returned if we were unable to build a SimpleService_TransHeadersType_Args struct
// from the provided intermediate representation.
//
//	x, err := binaryProtocol.Decode(reader, wire.TStruct)
//	if err != nil {
//	  return nil, err
//	}
//
//	var v SimpleService_TransHeadersType_Args
//	if err := v.FromWire(x); err != nil {
//	  return nil, err
//	}
//	return &v, nil
func (v *SimpleService_TransHeadersType_Args) FromWire(w wire.Value) error {
	var err error

	reqIsSet := false

	for _, field := range w.GetStruct().Fields {
		switch field.ID {
		case 1:
			if field.Value.Type() == wire.TStruct {
				v.Req, err = _TransHeader_Read(field.Value)
				if err != nil {
					return err
				}
				reqIsSet = true
			}
		}
	}

	if !reqIsSet {
		return errors.New("field Req of SimpleService_TransHeadersType_Args is required")
	}

	return nil
}

// Encode serializes a SimpleService_TransHeadersType_Args struct directly into bytes, without going
// through an intermediary type.
//
// An error is returned if a SimpleService_TransHeadersType_Args struct could not be encoded.
func (v *SimpleService_TransHeadersType_Args) Encode(sw stream.Writer) error {
	if err := sw.WriteStructBegin(); err != nil {
		return err
	}

	if v.Req == nil {
		return errors.New("field Req of SimpleService_TransHeadersType_Args is required")
	}
	if err := sw.WriteFieldBegin(stream.FieldHeader{ID: 1, Type: wire.TStruct}); err != nil {
		return err
	}
	if err := v.Req.Encode(sw); err != nil {
		return err
	}
	if err := sw.WriteFieldEnd(); err != nil {
		return err
	}

	return sw.WriteStructEnd()
}

// Decode deserializes a SimpleService_TransHeadersType_Args struct directly from its Thrift-level
// representation, without going through an intemediary type.
//
// An error is returned if a SimpleService_TransHeadersType_Args struct could not be generated from the wire
// representation.
func (v *SimpleService_TransHeadersType_Args) Decode(sr stream.Reader) error {

	reqIsSet := false

	if err := sr.ReadStructBegin(); err != nil {
		return err
	}

	fh, ok, err := sr.ReadFieldBegin()
	if err != nil {
		return err
	}

	for ok {
		switch {
		case fh.ID == 1 && fh.Type == wire.TStruct:
			v.Req, err = _TransHeader_Decode(sr)
			if err != nil {
				return err
			}
			reqIsSet = true
		default:
			if err := sr.Skip(fh.Type); err != nil {
				return err
			}
		}

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

		if fh, ok, err = sr.ReadFieldBegin(); err != nil {
			return err
		}
	}

	if err := sr.ReadStructEnd(); err != nil {
		return err
	}

	if !reqIsSet {
		return errors.New("field Req of SimpleService_TransHeadersType_Args is required")
	}

	return nil
}

// String returns a readable string representation of a SimpleService_TransHeadersType_Args
// struct.
func (v *SimpleService_TransHeadersType_Args) String() string {
	if v == nil {
		return "<nil>"
	}

	var fields [1]string
	i := 0
	fields[i] = fmt.Sprintf("Req: %v", v.Req)
	i++

	return fmt.Sprintf("SimpleService_TransHeadersType_Args{%v}", strings.Join(fields[:i], ", "))
}

// Equals returns true if all the fields of this SimpleService_TransHeadersType_Args match the
// provided SimpleService_TransHeadersType_Args.
//
// This function performs a deep comparison.
func (v *SimpleService_TransHeadersType_Args) Equals(rhs *SimpleService_TransHeadersType_Args) bool {
	if v == nil {
		return rhs == nil
	} else if rhs == nil {
		return false
	}
	if !v.Req.Equals(rhs.Req) {
		return false
	}

	return true
}

// MarshalLogObject implements zapcore.ObjectMarshaler, enabling
// fast logging of SimpleService_TransHeadersType_Args.
func (v *SimpleService_TransHeadersType_Args) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
	if v == nil {
		return nil
	}
	err = multierr.Append(err, enc.AddObject("req", v.Req))
	return err
}

// GetReq returns the value of Req if it is set or its
// zero value if it is unset.
func (v *SimpleService_TransHeadersType_Args) GetReq() (o *TransHeader) {
	if v != nil {
		o = v.Req
	}
	return
}

// IsSetReq returns true if Req is not nil.
func (v *SimpleService_TransHeadersType_Args) IsSetReq() bool {
	return v != nil && v.Req != nil
}

// MethodName returns the name of the Thrift function as specified in
// the IDL, for which this struct represent the arguments.
//
// This will always be "transHeadersType" for this struct.
func (v *SimpleService_TransHeadersType_Args) MethodName() string {
	return "transHeadersType"
}

// EnvelopeType returns the kind of value inside this struct.
//
// This will always be Call for this struct.
func (v *SimpleService_TransHeadersType_Args) EnvelopeType() wire.EnvelopeType {
	return wire.Call
}

// SimpleService_TransHeadersType_Helper provides functions that aid in handling the
// parameters and return values of the SimpleService.transHeadersType
// function.
var SimpleService_TransHeadersType_Helper = struct {
	// Args accepts the parameters of transHeadersType in-order and returns
	// the arguments struct for the function.
	Args func(
		req *TransHeader,
	) *SimpleService_TransHeadersType_Args

	// IsException returns true if the given error can be thrown
	// by transHeadersType.
	//
	// An error can be thrown by transHeadersType only if the
	// corresponding exception type was mentioned in the 'throws'
	// section for it in the Thrift file.
	IsException func(error) bool

	// WrapResponse returns the result struct for transHeadersType
	// given its return value and error.
	//
	// This allows mapping values and errors returned by
	// transHeadersType into a serializable result struct.
	// WrapResponse returns a non-nil error if the provided
	// error cannot be thrown by transHeadersType
	//
	//   value, err := transHeadersType(args)
	//   result, err := SimpleService_TransHeadersType_Helper.WrapResponse(value, err)
	//   if err != nil {
	//     return fmt.Errorf("unexpected error from transHeadersType: %v", err)
	//   }
	//   serialize(result)
	WrapResponse func(*TransHeader, error) (*SimpleService_TransHeadersType_Result, error)

	// UnwrapResponse takes the result struct for transHeadersType
	// and returns the value or error returned by it.
	//
	// The error is non-nil only if transHeadersType threw an
	// exception.
	//
	//   result := deserialize(bytes)
	//   value, err := SimpleService_TransHeadersType_Helper.UnwrapResponse(result)
	UnwrapResponse func(*SimpleService_TransHeadersType_Result) (*TransHeader, error)
}{}

func init() {
	SimpleService_TransHeadersType_Helper.Args = func(
		req *TransHeader,
	) *SimpleService_TransHeadersType_Args {
		return &SimpleService_TransHeadersType_Args{
			Req: req,
		}
	}

	SimpleService_TransHeadersType_Helper.IsException = func(err error) bool {
		switch err.(type) {
		case *AuthErr:
			return true
		case *OtherAuthErr:
			return true
		default:
			return false
		}
	}

	SimpleService_TransHeadersType_Helper.WrapResponse = func(success *TransHeader, err error) (*SimpleService_TransHeadersType_Result, error) {
		if err == nil {
			return &SimpleService_TransHeadersType_Result{Success: success}, nil
		}

		switch e := err.(type) {
		case *AuthErr:
			if e == nil {
				return nil, errors.New("WrapResponse received non-nil error type with nil value for SimpleService_TransHeadersType_Result.AuthErr")
			}
			return &SimpleService_TransHeadersType_Result{AuthErr: e}, nil
		case *OtherAuthErr:
			if e == nil {
				return nil, errors.New("WrapResponse received non-nil error type with nil value for SimpleService_TransHeadersType_Result.OtherAuthErr")
			}
			return &SimpleService_TransHeadersType_Result{OtherAuthErr: e}, nil
		}

		return nil, err
	}
	SimpleService_TransHeadersType_Helper.UnwrapResponse = func(result *SimpleService_TransHeadersType_Result) (success *TransHeader, err error) {
		if result.AuthErr != nil {
			err = result.AuthErr
			return
		}
		if result.OtherAuthErr != nil {
			err = result.OtherAuthErr
			return
		}

		if result.Success != nil {
			success = result.Success
			return
		}

		err = errors.New("expected a non-void result")
		return
	}

}

// SimpleService_TransHeadersType_Result represents the result of a SimpleService.transHeadersType function call.
//
// The result of a transHeadersType execution is sent and received over the wire as this struct.
//
// Success is set only if the function did not throw an exception.
type SimpleService_TransHeadersType_Result struct {
	// Value returned by transHeadersType after a successful execution.
	Success      *TransHeader  `json:"success,omitempty"`
	AuthErr      *AuthErr      `json:"authErr,omitempty"`
	OtherAuthErr *OtherAuthErr `json:"otherAuthErr,omitempty"`
}

// ToWire translates a SimpleService_TransHeadersType_Result struct into a Thrift-level intermediate
// representation. This intermediate representation may be serialized
// into bytes using a ThriftRW protocol implementation.
//
// An error is returned if the struct or any of its fields failed to
// validate.
//
//	x, err := v.ToWire()
//	if err != nil {
//	  return err
//	}
//
//	if err := binaryProtocol.Encode(x, writer); err != nil {
//	  return err
//	}
func (v *SimpleService_TransHeadersType_Result) ToWire() (wire.Value, error) {
	var (
		fields [3]wire.Field
		i      int = 0
		w      wire.Value
		err    error
	)

	if v.Success != nil {
		w, err = v.Success.ToWire()
		if err != nil {
			return w, err
		}
		fields[i] = wire.Field{ID: 0, Value: w}
		i++
	}
	if v.AuthErr != nil {
		w, err = v.AuthErr.ToWire()
		if err != nil {
			return w, err
		}
		fields[i] = wire.Field{ID: 1, Value: w}
		i++
	}
	if v.OtherAuthErr != nil {
		w, err = v.OtherAuthErr.ToWire()
		if err != nil {
			return w, err
		}
		fields[i] = wire.Field{ID: 2, Value: w}
		i++
	}

	if i != 1 {
		return wire.Value{}, fmt.Errorf("SimpleService_TransHeadersType_Result should have exactly one field: got %v fields", i)
	}

	return wire.NewValueStruct(wire.Struct{Fields: fields[:i]}), nil
}

// FromWire deserializes a SimpleService_TransHeadersType_Result struct from its Thrift-level
// representation. The Thrift-level representation may be obtained
// from a ThriftRW protocol implementation.
//
// An error is returned if we were unable to build a SimpleService_TransHeadersType_Result struct
// from the provided intermediate representation.
//
//	x, err := binaryProtocol.Decode(reader, wire.TStruct)
//	if err != nil {
//	  return nil, err
//	}
//
//	var v SimpleService_TransHeadersType_Result
//	if err := v.FromWire(x); err != nil {
//	  return nil, err
//	}
//	return &v, nil
func (v *SimpleService_TransHeadersType_Result) FromWire(w wire.Value) error {
	var err error

	for _, field := range w.GetStruct().Fields {
		switch field.ID {
		case 0:
			if field.Value.Type() == wire.TStruct {
				v.Success, err = _TransHeader_Read(field.Value)
				if err != nil {
					return err
				}

			}
		case 1:
			if field.Value.Type() == wire.TStruct {
				v.AuthErr, err = _AuthErr_Read(field.Value)
				if err != nil {
					return err
				}

			}
		case 2:
			if field.Value.Type() == wire.TStruct {
				v.OtherAuthErr, err = _OtherAuthErr_Read(field.Value)
				if err != nil {
					return err
				}

			}
		}
	}

	count := 0
	if v.Success != nil {
		count++
	}
	if v.AuthErr != nil {
		count++
	}
	if v.OtherAuthErr != nil {
		count++
	}
	if count != 1 {
		return fmt.Errorf("SimpleService_TransHeadersType_Result should have exactly one field: got %v fields", count)
	}

	return nil
}

// Encode serializes a SimpleService_TransHeadersType_Result struct directly into bytes, without going
// through an intermediary type.
//
// An error is returned if a SimpleService_TransHeadersType_Result struct could not be encoded.
func (v *SimpleService_TransHeadersType_Result) Encode(sw stream.Writer) error {
	if err := sw.WriteStructBegin(); err != nil {
		return err
	}

	if v.Success != nil {
		if err := sw.WriteFieldBegin(stream.FieldHeader{ID: 0, Type: wire.TStruct}); err != nil {
			return err
		}
		if err := v.Success.Encode(sw); err != nil {
			return err
		}
		if err := sw.WriteFieldEnd(); err != nil {
			return err
		}
	}

	if v.AuthErr != nil {
		if err := sw.WriteFieldBegin(stream.FieldHeader{ID: 1, Type: wire.TStruct}); err != nil {
			return err
		}
		if err := v.AuthErr.Encode(sw); err != nil {
			return err
		}
		if err := sw.WriteFieldEnd(); err != nil {
			return err
		}
	}

	if v.OtherAuthErr != nil {
		if err := sw.WriteFieldBegin(stream.FieldHeader{ID: 2, Type: wire.TStruct}); err != nil {
			return err
		}
		if err := v.OtherAuthErr.Encode(sw); err != nil {
			return err
		}
		if err := sw.WriteFieldEnd(); err != nil {
			return err
		}
	}

	count := 0
	if v.Success != nil {
		count++
	}
	if v.AuthErr != nil {
		count++
	}
	if v.OtherAuthErr != nil {
		count++
	}

	if count != 1 {
		return fmt.Errorf("SimpleService_TransHeadersType_Result should have exactly one field: got %v fields", count)
	}

	return sw.WriteStructEnd()
}

// Decode deserializes a SimpleService_TransHeadersType_Result struct directly from its Thrift-level
// representation, without going through an intemediary type.
//
// An error is returned if a SimpleService_TransHeadersType_Result struct could not be generated from the wire
// representation.
func (v *SimpleService_TransHeadersType_Result) Decode(sr stream.Reader) error {

	if err := sr.ReadStructBegin(); err != nil {
		return err
	}

	fh, ok, err := sr.ReadFieldBegin()
	if err != nil {
		return err
	}

	for ok {
		switch {
		case fh.ID == 0 && fh.Type == wire.TStruct:
			v.Success, err = _TransHeader_Decode(sr)
			if err != nil {
				return err
			}

		case fh.ID == 1 && fh.Type == wire.TStruct:
			v.AuthErr, err = _AuthErr_Decode(sr)
			if err != nil {
				return err
			}

		case fh.ID == 2 && fh.Type == wire.TStruct:
			v.OtherAuthErr, err = _OtherAuthErr_Decode(sr)
			if err != nil {
				return err
			}

		default:
			if err := sr.Skip(fh.Type); err != nil {
				return err
			}
		}

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

		if fh, ok, err = sr.ReadFieldBegin(); err != nil {
			return err
		}
	}

	if err := sr.ReadStructEnd(); err != nil {
		return err
	}

	count := 0
	if v.Success != nil {
		count++
	}
	if v.AuthErr != nil {
		count++
	}
	if v.OtherAuthErr != nil {
		count++
	}
	if count != 1 {
		return fmt.Errorf("SimpleService_TransHeadersType_Result should have exactly one field: got %v fields", count)
	}

	return nil
}

// String returns a readable string representation of a SimpleService_TransHeadersType_Result
// struct.
func (v *SimpleService_TransHeadersType_Result) String() string {
	if v == nil {
		return "<nil>"
	}

	var fields [3]string
	i := 0
	if v.Success != nil {
		fields[i] = fmt.Sprintf("Success: %v", v.Success)
		i++
	}
	if v.AuthErr != nil {
		fields[i] = fmt.Sprintf("AuthErr: %v", v.AuthErr)
		i++
	}
	if v.OtherAuthErr != nil {
		fields[i] = fmt.Sprintf("OtherAuthErr: %v", v.OtherAuthErr)
		i++
	}

	return fmt.Sprintf("SimpleService_TransHeadersType_Result{%v}", strings.Join(fields[:i], ", "))
}

// Equals returns true if all the fields of this SimpleService_TransHeadersType_Result match the
// provided SimpleService_TransHeadersType_Result.
//
// This function performs a deep comparison.
func (v *SimpleService_TransHeadersType_Result) Equals(rhs *SimpleService_TransHeadersType_Result) bool {
	if v == nil {
		return rhs == nil
	} else if rhs == nil {
		return false
	}
	if !((v.Success == nil && rhs.Success == nil) || (v.Success != nil && rhs.Success != nil && v.Success.Equals(rhs.Success))) {
		return false
	}
	if !((v.AuthErr == nil && rhs.AuthErr == nil) || (v.AuthErr != nil && rhs.AuthErr != nil && v.AuthErr.Equals(rhs.AuthErr))) {
		return false
	}
	if !((v.OtherAuthErr == nil && rhs.OtherAuthErr == nil) || (v.OtherAuthErr != nil && rhs.OtherAuthErr != nil && v.OtherAuthErr.Equals(rhs.OtherAuthErr))) {
		return false
	}

	return true
}

// MarshalLogObject implements zapcore.ObjectMarshaler, enabling
// fast logging of SimpleService_TransHeadersType_Result.
func (v *SimpleService_TransHeadersType_Result) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
	if v == nil {
		return nil
	}
	if v.Success != nil {
		err = multierr.Append(err, enc.AddObject("success", v.Success))
	}
	if v.AuthErr != nil {
		err = multierr.Append(err, enc.AddObject("authErr", v.AuthErr))
	}
	if v.OtherAuthErr != nil {
		err = multierr.Append(err, enc.AddObject("otherAuthErr", v.OtherAuthErr))
	}
	return err
}

// GetSuccess returns the value of Success if it is set or its
// zero value if it is unset.
func (v *SimpleService_TransHeadersType_Result) GetSuccess() (o *TransHeader) {
	if v != nil && v.Success != nil {
		return v.Success
	}

	return
}

// IsSetSuccess returns true if Success is not nil.
func (v *SimpleService_TransHeadersType_Result) IsSetSuccess() bool {
	return v != nil && v.Success != nil
}

// GetAuthErr returns the value of AuthErr if it is set or its
// zero value if it is unset.
func (v *SimpleService_TransHeadersType_Result) GetAuthErr() (o *AuthErr) {
	if v != nil && v.AuthErr != nil {
		return v.AuthErr
	}

	return
}

// IsSetAuthErr returns true if AuthErr is not nil.
func (v *SimpleService_TransHeadersType_Result) IsSetAuthErr() bool {
	return v != nil && v.AuthErr != nil
}

// GetOtherAuthErr returns the value of OtherAuthErr if it is set or its
// zero value if it is unset.
func (v *SimpleService_TransHeadersType_Result) GetOtherAuthErr() (o *OtherAuthErr) {
	if v != nil && v.OtherAuthErr != nil {
		return v.OtherAuthErr
	}

	return
}

// IsSetOtherAuthErr returns true if OtherAuthErr is not nil.
func (v *SimpleService_TransHeadersType_Result) IsSetOtherAuthErr() bool {
	return v != nil && v.OtherAuthErr != nil
}

// MethodName returns the name of the Thrift function as specified in
// the IDL, for which this struct represent the result.
//
// This will always be "transHeadersType" for this struct.
func (v *SimpleService_TransHeadersType_Result) MethodName() string {
	return "transHeadersType"
}

// EnvelopeType returns the kind of value inside this struct.
//
// This will always be Reply for this struct.
func (v *SimpleService_TransHeadersType_Result) EnvelopeType() wire.EnvelopeType {
	return wire.Reply
}

// SimpleService_UrlTest_Args represents the arguments for the SimpleService.urlTest function.
//
// The arguments for urlTest are sent and received over the wire as this struct.
type SimpleService_UrlTest_Args struct {
}

// ToWire translates a SimpleService_UrlTest_Args struct into a Thrift-level intermediate
// representation. This intermediate representation may be serialized
// into bytes using a ThriftRW protocol implementation.
//
// An error is returned if the struct or any of its fields failed to
// validate.
//
//	x, err := v.ToWire()
//	if err != nil {
//	  return err
//	}
//
//	if err := binaryProtocol.Encode(x, writer); err != nil {
//	  return err
//	}
func (v *SimpleService_UrlTest_Args) ToWire() (wire.Value, error) {
	var (
		fields [0]wire.Field
		i      int = 0
	)

	return wire.NewValueStruct(wire.Struct{Fields: fields[:i]}), nil
}

// FromWire deserializes a SimpleService_UrlTest_Args struct from its Thrift-level
// representation. The Thrift-level representation may be obtained
// from a ThriftRW protocol implementation.
//
// An error is returned if we were unable to build a SimpleService_UrlTest_Args struct
// from the provided intermediate representation.
//
//	x, err := binaryProtocol.Decode(reader, wire.TStruct)
//	if err != nil {
//	  return nil, err
//	}
//
//	var v SimpleService_UrlTest_Args
//	if err := v.FromWire(x); err != nil {
//	  return nil, err
//	}
//	return &v, nil
func (v *SimpleService_UrlTest_Args) FromWire(w wire.Value) error {

	for _, field := range w.GetStruct().Fields {
		switch field.ID {
		}
	}

	return nil
}

// Encode serializes a SimpleService_UrlTest_Args struct directly into bytes, without going
// through an intermediary type.
//
// An error is returned if a SimpleService_UrlTest_Args struct could not be encoded.
func (v *SimpleService_UrlTest_Args) Encode(sw stream.Writer) error {
	if err := sw.WriteStructBegin(); err != nil {
		return err
	}

	return sw.WriteStructEnd()
}

// Decode deserializes a SimpleService_UrlTest_Args struct directly from its Thrift-level
// representation, without going through an intemediary type.
//
// An error is returned if a SimpleService_UrlTest_Args struct could not be generated from the wire
// representation.
func (v *SimpleService_UrlTest_Args) Decode(sr stream.Reader) error {

	if err := sr.ReadStructBegin(); err != nil {
		return err
	}

	fh, ok, err := sr.ReadFieldBegin()
	if err != nil {
		return err
	}

	for ok {
		switch {
		default:
			if err := sr.Skip(fh.Type); err != nil {
				return err
			}
		}

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

		if fh, ok, err = sr.ReadFieldBegin(); err != nil {
			return err
		}
	}

	if err := sr.ReadStructEnd(); err != nil {
		return err
	}

	return nil
}

// String returns a readable string representation of a SimpleService_UrlTest_Args
// struct.
func (v *SimpleService_UrlTest_Args) String() string {
	if v == nil {
		return "<nil>"
	}

	var fields [0]string
	i := 0

	return fmt.Sprintf("SimpleService_UrlTest_Args{%v}", strings.Join(fields[:i], ", "))
}

// Equals returns true if all the fields of this SimpleService_UrlTest_Args match the
// provided SimpleService_UrlTest_Args.
//
// This function performs a deep comparison.
func (v *SimpleService_UrlTest_Args) Equals(rhs *SimpleService_UrlTest_Args) bool {
	if v == nil {
		return rhs == nil
	} else if rhs == nil {
		return false
	}

	return true
}

// MarshalLogObject implements zapcore.ObjectMarshaler, enabling
// fast logging of SimpleService_UrlTest_Args.
func (v *SimpleService_UrlTest_Args) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
	if v == nil {
		return nil
	}
	return err
}

// MethodName returns the name of the Thrift function as specified in
// the IDL, for which this struct represent the arguments.
//
// This will always be "urlTest" for this struct.
func (v *SimpleService_UrlTest_Args) MethodName() string {
	return "urlTest"
}

// EnvelopeType returns the kind of value inside this struct.
//
// This will always be Call for this struct.
func (v *SimpleService_UrlTest_Args) EnvelopeType() wire.EnvelopeType {
	return wire.Call
}

// SimpleService_UrlTest_Helper provides functions that aid in handling the
// parameters and return values of the SimpleService.urlTest
// function.
var SimpleService_UrlTest_Helper = struct {
	// Args accepts the parameters of urlTest in-order and returns
	// the arguments struct for the function.
	Args func() *SimpleService_UrlTest_Args

	// IsException returns true if the given error can be thrown
	// by urlTest.
	//
	// An error can be thrown by urlTest only if the
	// corresponding exception type was mentioned in the 'throws'
	// section for it in the Thrift file.
	IsException func(error) bool

	// WrapResponse returns the result struct for urlTest
	// given the error returned by it. The provided error may
	// be nil if urlTest did not fail.
	//
	// This allows mapping errors returned by urlTest into a
	// serializable result struct. WrapResponse returns a
	// non-nil error if the provided error cannot be thrown by
	// urlTest
	//
	//   err := urlTest(args)
	//   result, err := SimpleService_UrlTest_Helper.WrapResponse(err)
	//   if err != nil {
	//     return fmt.Errorf("unexpected error from urlTest: %v", err)
	//   }
	//   serialize(result)
	WrapResponse func(error) (*SimpleService_UrlTest_Result, error)

	// UnwrapResponse takes the result struct for urlTest
	// and returns the erorr returned by it (if any).
	//
	// The error is non-nil only if urlTest threw an
	// exception.
	//
	//   result := deserialize(bytes)
	//   err := SimpleService_UrlTest_Helper.UnwrapResponse(result)
	UnwrapResponse func(*SimpleService_UrlTest_Result) error
}{}

func init() {
	SimpleService_UrlTest_Helper.Args = func() *SimpleService_UrlTest_Args {
		return &SimpleService_UrlTest_Args{}
	}

	SimpleService_UrlTest_Helper.IsException = func(err error) bool {
		switch err.(type) {
		default:
			return false
		}
	}

	SimpleService_UrlTest_Helper.WrapResponse = func(err error) (*SimpleService_UrlTest_Result, error) {
		if err == nil {
			return &SimpleService_UrlTest_Result{}, nil
		}

		return nil, err
	}
	SimpleService_UrlTest_Helper.UnwrapResponse = func(result *SimpleService_UrlTest_Result) (err error) {
		return
	}

}

// SimpleService_UrlTest_Result represents the result of a SimpleService.urlTest function call.
//
// The result of a urlTest execution is sent and received over the wire as this struct.
type SimpleService_UrlTest_Result struct {
}

// ToWire translates a SimpleService_UrlTest_Result struct into a Thrift-level intermediate
// representation. This intermediate representation may be serialized
// into bytes using a ThriftRW protocol implementation.
//
// An error is returned if the struct or any of its fields failed to
// validate.
//
//	x, err := v.ToWire()
//	if err != nil {
//	  return err
//	}
//
//	if err := binaryProtocol.Encode(x, writer); err != nil {
//	  return err
//	}
func (v *SimpleService_UrlTest_Result) ToWire() (wire.Value, error) {
	var (
		fields [0]wire.Field
		i      int = 0
	)

	return wire.NewValueStruct(wire.Struct{Fields: fields[:i]}), nil
}

// FromWire deserializes a SimpleService_UrlTest_Result struct from its Thrift-level
// representation. The Thrift-level representation may be obtained
// from a ThriftRW protocol implementation.
//
// An error is returned if we were unable to build a SimpleService_UrlTest_Result struct
// from the provided intermediate representation.
//
//	x, err := binaryProtocol.Decode(reader, wire.TStruct)
//	if err != nil {
//	  return nil, err
//	}
//
//	var v SimpleService_UrlTest_Result
//	if err := v.FromWire(x); err != nil {
//	  return nil, err
//	}
//	return &v, nil
func (v *SimpleService_UrlTest_Result) FromWire(w wire.Value) error {

	for _, field := range w.GetStruct().Fields {
		switch field.ID {
		}
	}

	return nil
}

// Encode serializes a SimpleService_UrlTest_Result struct directly into bytes, without going
// through an intermediary type.
//
// An error is returned if a SimpleService_UrlTest_Result struct could not be encoded.
func (v *SimpleService_UrlTest_Result) Encode(sw stream.Writer) error {
	if err := sw.WriteStructBegin(); err != nil {
		return err
	}

	return sw.WriteStructEnd()
}

// Decode deserializes a SimpleService_UrlTest_Result struct directly from its Thrift-level
// representation, without going through an intemediary type.
//
// An error is returned if a SimpleService_UrlTest_Result struct could not be generated from the wire
// representation.
func (v *SimpleService_UrlTest_Result) Decode(sr stream.Reader) error {

	if err := sr.ReadStructBegin(); err != nil {
		return err
	}

	fh, ok, err := sr.ReadFieldBegin()
	if err != nil {
		return err
	}

	for ok {
		switch {
		default:
			if err := sr.Skip(fh.Type); err != nil {
				return err
			}
		}

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

		if fh, ok, err = sr.ReadFieldBegin(); err != nil {
			return err
		}
	}

	if err := sr.ReadStructEnd(); err != nil {
		return err
	}

	return nil
}

// String returns a readable string representation of a SimpleService_UrlTest_Result
// struct.
func (v *SimpleService_UrlTest_Result) String() string {
	if v == nil {
		return "<nil>"
	}

	var fields [0]string
	i := 0

	return fmt.Sprintf("SimpleService_UrlTest_Result{%v}", strings.Join(fields[:i], ", "))
}

// Equals returns true if all the fields of this SimpleService_UrlTest_Result match the
// provided SimpleService_UrlTest_Result.
//
// This function performs a deep comparison.
func (v *SimpleService_UrlTest_Result) Equals(rhs *SimpleService_UrlTest_Result) bool {
	if v == nil {
		return rhs == nil
	} else if rhs == nil {
		return false
	}

	return true
}

// MarshalLogObject implements zapcore.ObjectMarshaler, enabling
// fast logging of SimpleService_UrlTest_Result.
func (v *SimpleService_UrlTest_Result) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
	if v == nil {
		return nil
	}
	return err
}

// MethodName returns the name of the Thrift function as specified in
// the IDL, for which this struct represent the result.
//
// This will always be "urlTest" for this struct.
func (v *SimpleService_UrlTest_Result) MethodName() string {
	return "urlTest"
}

// EnvelopeType returns the kind of value inside this struct.
//
// This will always be Reply for this struct.
func (v *SimpleService_UrlTest_Result) EnvelopeType() wire.EnvelopeType {
	return wire.Reply
}