baz.go

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

package baz

import (
	bytes "bytes"
	base64 "encoding/base64"
	json "encoding/json"
	errors "errors"
	fmt "fmt"
	math "math"
	strconv "strconv"
	strings "strings"

	base "github.com/uber/zanzibar/examples/example-gateway/build/gen-code/clients-idl/clients/baz/base"
	multierr "go.uber.org/multierr"
	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
}

// 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
}

// 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 Fruit int32

const (
	FruitApple  Fruit = 0
	FruitBanana Fruit = 1
)

// Fruit_Values returns all recognized values of Fruit.
func Fruit_Values() []Fruit {
	return []Fruit{
		FruitApple,
		FruitBanana,
	}
}

// UnmarshalText tries to decode Fruit from a byte slice
// containing its name.
//
//   var v Fruit
//   err := v.UnmarshalText([]byte("APPLE"))
func (v *Fruit) UnmarshalText(value []byte) error {
	switch s := string(value); s {
	case "APPLE":
		*v = FruitApple
		return nil
	case "BANANA":
		*v = FruitBanana
		return nil
	default:
		val, err := strconv.ParseInt(s, 10, 32)
		if err != nil {
			return fmt.Errorf("unknown enum value %q for %q: %v", s, "Fruit", err)
		}
		*v = Fruit(val)
		return nil
	}
}

// MarshalText encodes Fruit to text.
//
// If the enum value is recognized, its name is returned. Otherwise,
// its integer value is returned.
//
// This implements the TextMarshaler interface.
func (v Fruit) MarshalText() ([]byte, error) {
	switch int32(v) {
	case 0:
		return []byte("APPLE"), nil
	case 1:
		return []byte("BANANA"), nil
	}
	return []byte(strconv.FormatInt(int64(v), 10)), nil
}

// MarshalLogObject implements zapcore.ObjectMarshaler, enabling
// fast logging of Fruit.
// Enums are logged as objects, where the value is logged with key "value", and
// if this value's name is known, the name is logged with key "name".
func (v Fruit) MarshalLogObject(enc zapcore.ObjectEncoder) error {
	enc.AddInt32("value", int32(v))
	switch int32(v) {
	case 0:
		enc.AddString("name", "APPLE")
	case 1:
		enc.AddString("name", "BANANA")
	}
	return nil
}

// Ptr returns a pointer to this enum value.
func (v Fruit) Ptr() *Fruit {
	return &v
}

// ToWire translates Fruit into a Thrift-level intermediate
// representation. This intermediate representation may be serialized
// into bytes using a ThriftRW protocol implementation.
//
// Enums are represented as 32-bit integers over the wire.
func (v Fruit) ToWire() (wire.Value, error) {
	return wire.NewValueI32(int32(v)), nil
}

// FromWire deserializes Fruit from its Thrift-level
// representation.
//
//   x, err := binaryProtocol.Decode(reader, wire.TI32)
//   if err != nil {
//     return Fruit(0), err
//   }
//
//   var v Fruit
//   if err := v.FromWire(x); err != nil {
//     return Fruit(0), err
//   }
//   return v, nil
func (v *Fruit) FromWire(w wire.Value) error {
	*v = (Fruit)(w.GetI32())
	return nil
}

// String returns a readable string representation of Fruit.
func (v Fruit) String() string {
	w := int32(v)
	switch w {
	case 0:
		return "APPLE"
	case 1:
		return "BANANA"
	}
	return fmt.Sprintf("Fruit(%d)", w)
}

// Equals returns true if this Fruit value matches the provided
// value.
func (v Fruit) Equals(rhs Fruit) bool {
	return v == rhs
}

// MarshalJSON serializes Fruit into JSON.
//
// If the enum value is recognized, its name is returned. Otherwise,
// its integer value is returned.
//
// This implements json.Marshaler.
func (v Fruit) MarshalJSON() ([]byte, error) {
	switch int32(v) {
	case 0:
		return ([]byte)("\"APPLE\""), nil
	case 1:
		return ([]byte)("\"BANANA\""), nil
	}
	return ([]byte)(strconv.FormatInt(int64(v), 10)), nil
}

// UnmarshalJSON attempts to decode Fruit from its JSON
// representation.
//
// This implementation supports both, numeric and string inputs. If a
// string is provided, it must be a known enum name.
//
// This implements json.Unmarshaler.
func (v *Fruit) UnmarshalJSON(text []byte) error {
	d := json.NewDecoder(bytes.NewReader(text))
	d.UseNumber()
	t, err := d.Token()
	if err != nil {
		return err
	}

	switch w := t.(type) {
	case json.Number:
		x, err := w.Int64()
		if err != nil {
			return err
		}
		if x > math.MaxInt32 {
			return fmt.Errorf("enum overflow from JSON %q for %q", text, "Fruit")
		}
		if x < math.MinInt32 {
			return fmt.Errorf("enum underflow from JSON %q for %q", text, "Fruit")
		}
		*v = (Fruit)(x)
		return nil
	case string:
		return v.UnmarshalText([]byte(w))
	default:
		return fmt.Errorf("invalid JSON value %q (%T) to unmarshal into %q", t, t, "Fruit")
	}
}

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
}

// 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 [%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
}

// 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
}

// 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 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
}

// 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
}

// 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 [%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
}

// 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,omitempty"`
}

// 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 {
		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

	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
				}

			}
		}
	}

	if !field21IsSet {
		return errors.New("field Field21 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++
	if v.Field22 != nil {
		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 == nil && rhs.Field22 == nil) || (v.Field22 != nil && rhs.Field22 != nil && 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))
	if v.Field22 != nil {
		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 && v.Field22 != nil {
		return 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
}

// 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 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)
}

// 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
}

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

type TransHeaderType struct {
	B1 bool     `json:"b1,required"`
	I1 *int32   `json:"i1,omitempty"`
	I2 int64    `json:"i2,required"`
	F3 *float64 `json:"f3,omitempty"`
	U4 UUID     `json:"u4,required"`
	U5 *UUID    `json:"u5,omitempty"`
	S6 string   `json:"s6,required"`
}

// ToWire translates a TransHeaderType 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 *TransHeaderType) ToWire() (wire.Value, error) {
	var (
		fields [7]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++
	if v.I1 != nil {
		w, err = wire.NewValueI32(*(v.I1)), error(nil)
		if err != nil {
			return w, err
		}
		fields[i] = wire.Field{ID: 2, Value: w}
		i++
	}

	w, err = wire.NewValueI64(v.I2), error(nil)
	if err != nil {
		return w, err
	}
	fields[i] = wire.Field{ID: 3, Value: w}
	i++
	if v.F3 != nil {
		w, err = wire.NewValueDouble(*(v.F3)), error(nil)
		if err != nil {
			return w, err
		}
		fields[i] = wire.Field{ID: 4, Value: w}
		i++
	}

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

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

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

// FromWire deserializes a TransHeaderType 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 TransHeaderType struct
// from the provided intermediate representation.
//
//   x, err := binaryProtocol.Decode(reader, wire.TStruct)
//   if err != nil {
//     return nil, err
//   }
//
//   var v TransHeaderType
//   if err := v.FromWire(x); err != nil {
//     return nil, err
//   }
//   return &v, nil
func (v *TransHeaderType) FromWire(w wire.Value) error {
	var err error

	b1IsSet := false

	i2IsSet := false

	u4IsSet := false

	s6IsSet := 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.TI32 {
				var x int32
				x, err = field.Value.GetI32(), error(nil)
				v.I1 = &x
				if err != nil {
					return err
				}

			}
		case 3:
			if field.Value.Type() == wire.TI64 {
				v.I2, err = field.Value.GetI64(), error(nil)
				if err != nil {
					return err
				}
				i2IsSet = true
			}
		case 4:
			if field.Value.Type() == wire.TDouble {
				var x float64
				x, err = field.Value.GetDouble(), error(nil)
				v.F3 = &x
				if err != nil {
					return err
				}

			}
		case 5:
			if field.Value.Type() == wire.TBinary {
				v.U4, err = _UUID_Read(field.Value)
				if err != nil {
					return err
				}
				u4IsSet = true
			}
		case 6:
			if field.Value.Type() == wire.TBinary {
				var x UUID
				x, err = _UUID_Read(field.Value)
				v.U5 = &x
				if err != nil {
					return err
				}

			}
		case 7:
			if field.Value.Type() == wire.TBinary {
				v.S6, err = field.Value.GetString(), error(nil)
				if err != nil {
					return err
				}
				s6IsSet = true
			}
		}
	}

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

	if !i2IsSet {
		return errors.New("field I2 of TransHeaderType is required")
	}

	if !u4IsSet {
		return errors.New("field U4 of TransHeaderType is required")
	}

	if !s6IsSet {
		return errors.New("field S6 of TransHeaderType is required")
	}

	return nil
}

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

	var fields [7]string
	i := 0
	fields[i] = fmt.Sprintf("B1: %v", v.B1)
	i++
	if v.I1 != nil {
		fields[i] = fmt.Sprintf("I1: %v", *(v.I1))
		i++
	}
	fields[i] = fmt.Sprintf("I2: %v", v.I2)
	i++
	if v.F3 != nil {
		fields[i] = fmt.Sprintf("F3: %v", *(v.F3))
		i++
	}
	fields[i] = fmt.Sprintf("U4: %v", v.U4)
	i++
	if v.U5 != nil {
		fields[i] = fmt.Sprintf("U5: %v", *(v.U5))
		i++
	}
	fields[i] = fmt.Sprintf("S6: %v", v.S6)
	i++

	return fmt.Sprintf("TransHeaderType{%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
}

func _Double_EqualsPtr(lhs, rhs *float64) 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 TransHeaderType match the
// provided TransHeaderType.
//
// This function performs a deep comparison.
func (v *TransHeaderType) Equals(rhs *TransHeaderType) bool {
	if v == nil {
		return rhs == nil
	} else if rhs == nil {
		return false
	}
	if !(v.B1 == rhs.B1) {
		return false
	}
	if !_I32_EqualsPtr(v.I1, rhs.I1) {
		return false
	}
	if !(v.I2 == rhs.I2) {
		return false
	}
	if !_Double_EqualsPtr(v.F3, rhs.F3) {
		return false
	}
	if !(v.U4 == rhs.U4) {
		return false
	}
	if !_UUID_EqualsPtr(v.U5, rhs.U5) {
		return false
	}
	if !(v.S6 == rhs.S6) {
		return false
	}

	return true
}

// MarshalLogObject implements zapcore.ObjectMarshaler, enabling
// fast logging of TransHeaderType.
func (v *TransHeaderType) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
	if v == nil {
		return nil
	}
	enc.AddBool("b1", v.B1)
	if v.I1 != nil {
		enc.AddInt32("i1", *v.I1)
	}
	enc.AddInt64("i2", v.I2)
	if v.F3 != nil {
		enc.AddFloat64("f3", *v.F3)
	}
	enc.AddString("u4", (string)(v.U4))
	if v.U5 != nil {
		enc.AddString("u5", (string)(*v.U5))
	}
	enc.AddString("s6", v.S6)
	return err
}

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

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

	return
}

// IsSetI1 returns true if I1 is not nil.
func (v *TransHeaderType) IsSetI1() bool {
	return v != nil && v.I1 != nil
}

// GetI2 returns the value of I2 if it is set or its
// zero value if it is unset.
func (v *TransHeaderType) GetI2() (o int64) {
	if v != nil {
		o = v.I2
	}
	return
}

// GetF3 returns the value of F3 if it is set or its
// zero value if it is unset.
func (v *TransHeaderType) GetF3() (o float64) {
	if v != nil && v.F3 != nil {
		return *v.F3
	}

	return
}

// IsSetF3 returns true if F3 is not nil.
func (v *TransHeaderType) IsSetF3() bool {
	return v != nil && v.F3 != nil
}

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

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

	return
}

// IsSetU5 returns true if U5 is not nil.
func (v *TransHeaderType) IsSetU5() bool {
	return v != nil && v.U5 != nil
}

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

// SecondService_EchoBinary_Args represents the arguments for the SecondService.echoBinary function.
//
// The arguments for echoBinary are sent and received over the wire as this struct.
type SecondService_EchoBinary_Args struct {
	Arg []byte `json:"arg,required"`
}

// ToWire translates a SecondService_EchoBinary_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 *SecondService_EchoBinary_Args) ToWire() (wire.Value, error) {
	var (
		fields [1]wire.Field
		i      int = 0
		w      wire.Value
		err    error
	)

	if v.Arg == nil {
		return w, errors.New("field Arg of SecondService_EchoBinary_Args is required")
	}
	w, err = wire.NewValueBinary(v.Arg), 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 SecondService_EchoBinary_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 SecondService_EchoBinary_Args struct
// from the provided intermediate representation.
//
//   x, err := binaryProtocol.Decode(reader, wire.TStruct)
//   if err != nil {
//     return nil, err
//   }
//
//   var v SecondService_EchoBinary_Args
//   if err := v.FromWire(x); err != nil {
//     return nil, err
//   }
//   return &v, nil
func (v *SecondService_EchoBinary_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.TBinary {
				v.Arg, err = field.Value.GetBinary(), error(nil)
				if err != nil {
					return err
				}
				argIsSet = true
			}
		}
	}

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

	return nil
}

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

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

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

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

	return true
}

// MarshalLogObject implements zapcore.ObjectMarshaler, enabling
// fast logging of SecondService_EchoBinary_Args.
func (v *SecondService_EchoBinary_Args) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
	if v == nil {
		return nil
	}
	enc.AddString("arg", base64.StdEncoding.EncodeToString(v.Arg))
	return err
}

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

// IsSetArg returns true if Arg is not nil.
func (v *SecondService_EchoBinary_Args) IsSetArg() bool {
	return v != nil && v.Arg != 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 "echoBinary" for this struct.
func (v *SecondService_EchoBinary_Args) MethodName() string {
	return "echoBinary"
}

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

// SecondService_EchoBinary_Helper provides functions that aid in handling the
// parameters and return values of the SecondService.echoBinary
// function.
var SecondService_EchoBinary_Helper = struct {
	// Args accepts the parameters of echoBinary in-order and returns
	// the arguments struct for the function.
	Args func(
		arg []byte,
	) *SecondService_EchoBinary_Args

	// IsException returns true if the given error can be thrown
	// by echoBinary.
	//
	// An error can be thrown by echoBinary 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 echoBinary
	// given its return value and error.
	//
	// This allows mapping values and errors returned by
	// echoBinary into a serializable result struct.
	// WrapResponse returns a non-nil error if the provided
	// error cannot be thrown by echoBinary
	//
	//   value, err := echoBinary(args)
	//   result, err := SecondService_EchoBinary_Helper.WrapResponse(value, err)
	//   if err != nil {
	//     return fmt.Errorf("unexpected error from echoBinary: %v", err)
	//   }
	//   serialize(result)
	WrapResponse func([]byte, error) (*SecondService_EchoBinary_Result, error)

	// UnwrapResponse takes the result struct for echoBinary
	// and returns the value or error returned by it.
	//
	// The error is non-nil only if echoBinary threw an
	// exception.
	//
	//   result := deserialize(bytes)
	//   value, err := SecondService_EchoBinary_Helper.UnwrapResponse(result)
	UnwrapResponse func(*SecondService_EchoBinary_Result) ([]byte, error)
}{}

func init() {
	SecondService_EchoBinary_Helper.Args = func(
		arg []byte,
	) *SecondService_EchoBinary_Args {
		return &SecondService_EchoBinary_Args{
			Arg: arg,
		}
	}

	SecondService_EchoBinary_Helper.IsException = func(err error) bool {
		switch err.(type) {
		default:
			return false
		}
	}

	SecondService_EchoBinary_Helper.WrapResponse = func(success []byte, err error) (*SecondService_EchoBinary_Result, error) {
		if err == nil {
			return &SecondService_EchoBinary_Result{Success: success}, nil
		}

		return nil, err
	}
	SecondService_EchoBinary_Helper.UnwrapResponse = func(result *SecondService_EchoBinary_Result) (success []byte, err error) {

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

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

}

// SecondService_EchoBinary_Result represents the result of a SecondService.echoBinary function call.
//
// The result of a echoBinary execution is sent and received over the wire as this struct.
//
// Success is set only if the function did not throw an exception.
type SecondService_EchoBinary_Result struct {
	// Value returned by echoBinary after a successful execution.
	Success []byte `json:"success,omitempty"`
}

// ToWire translates a SecondService_EchoBinary_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 *SecondService_EchoBinary_Result) ToWire() (wire.Value, error) {
	var (
		fields [1]wire.Field
		i      int = 0
		w      wire.Value
		err    error
	)

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

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

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

// FromWire deserializes a SecondService_EchoBinary_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 SecondService_EchoBinary_Result struct
// from the provided intermediate representation.
//
//   x, err := binaryProtocol.Decode(reader, wire.TStruct)
//   if err != nil {
//     return nil, err
//   }
//
//   var v SecondService_EchoBinary_Result
//   if err := v.FromWire(x); err != nil {
//     return nil, err
//   }
//   return &v, nil
func (v *SecondService_EchoBinary_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.TBinary {
				v.Success, err = field.Value.GetBinary(), error(nil)
				if err != nil {
					return err
				}

			}
		}
	}

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

	return nil
}

// String returns a readable string representation of a SecondService_EchoBinary_Result
// struct.
func (v *SecondService_EchoBinary_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("SecondService_EchoBinary_Result{%v}", strings.Join(fields[:i], ", "))
}

// Equals returns true if all the fields of this SecondService_EchoBinary_Result match the
// provided SecondService_EchoBinary_Result.
//
// This function performs a deep comparison.
func (v *SecondService_EchoBinary_Result) Equals(rhs *SecondService_EchoBinary_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 && bytes.Equal(v.Success, rhs.Success))) {
		return false
	}

	return true
}

// MarshalLogObject implements zapcore.ObjectMarshaler, enabling
// fast logging of SecondService_EchoBinary_Result.
func (v *SecondService_EchoBinary_Result) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
	if v == nil {
		return nil
	}
	if v.Success != nil {
		enc.AddString("success", base64.StdEncoding.EncodeToString(v.Success))
	}
	return err
}

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

	return
}

// IsSetSuccess returns true if Success is not nil.
func (v *SecondService_EchoBinary_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 "echoBinary" for this struct.
func (v *SecondService_EchoBinary_Result) MethodName() string {
	return "echoBinary"
}

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

// SecondService_EchoBool_Args represents the arguments for the SecondService.echoBool function.
//
// The arguments for echoBool are sent and received over the wire as this struct.
type SecondService_EchoBool_Args struct {
	Arg bool `json:"arg,required"`
}

// ToWire translates a SecondService_EchoBool_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 *SecondService_EchoBool_Args) ToWire() (wire.Value, error) {
	var (
		fields [1]wire.Field
		i      int = 0
		w      wire.Value
		err    error
	)

	w, err = wire.NewValueBool(v.Arg), 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 SecondService_EchoBool_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 SecondService_EchoBool_Args struct
// from the provided intermediate representation.
//
//   x, err := binaryProtocol.Decode(reader, wire.TStruct)
//   if err != nil {
//     return nil, err
//   }
//
//   var v SecondService_EchoBool_Args
//   if err := v.FromWire(x); err != nil {
//     return nil, err
//   }
//   return &v, nil
func (v *SecondService_EchoBool_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.TBool {
				v.Arg, err = field.Value.GetBool(), error(nil)
				if err != nil {
					return err
				}
				argIsSet = true
			}
		}
	}

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

	return nil
}

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

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

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

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

	return true
}

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

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

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

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

// SecondService_EchoBool_Helper provides functions that aid in handling the
// parameters and return values of the SecondService.echoBool
// function.
var SecondService_EchoBool_Helper = struct {
	// Args accepts the parameters of echoBool in-order and returns
	// the arguments struct for the function.
	Args func(
		arg bool,
	) *SecondService_EchoBool_Args

	// IsException returns true if the given error can be thrown
	// by echoBool.
	//
	// An error can be thrown by echoBool 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 echoBool
	// given its return value and error.
	//
	// This allows mapping values and errors returned by
	// echoBool into a serializable result struct.
	// WrapResponse returns a non-nil error if the provided
	// error cannot be thrown by echoBool
	//
	//   value, err := echoBool(args)
	//   result, err := SecondService_EchoBool_Helper.WrapResponse(value, err)
	//   if err != nil {
	//     return fmt.Errorf("unexpected error from echoBool: %v", err)
	//   }
	//   serialize(result)
	WrapResponse func(bool, error) (*SecondService_EchoBool_Result, error)

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

func init() {
	SecondService_EchoBool_Helper.Args = func(
		arg bool,
	) *SecondService_EchoBool_Args {
		return &SecondService_EchoBool_Args{
			Arg: arg,
		}
	}

	SecondService_EchoBool_Helper.IsException = func(err error) bool {
		switch err.(type) {
		default:
			return false
		}
	}

	SecondService_EchoBool_Helper.WrapResponse = func(success bool, err error) (*SecondService_EchoBool_Result, error) {
		if err == nil {
			return &SecondService_EchoBool_Result{Success: &success}, nil
		}

		return nil, err
	}
	SecondService_EchoBool_Helper.UnwrapResponse = func(result *SecondService_EchoBool_Result) (success bool, err error) {

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

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

}

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

// ToWire translates a SecondService_EchoBool_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 *SecondService_EchoBool_Result) ToWire() (wire.Value, error) {
	var (
		fields [1]wire.Field
		i      int = 0
		w      wire.Value
		err    error
	)

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

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

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

// FromWire deserializes a SecondService_EchoBool_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 SecondService_EchoBool_Result struct
// from the provided intermediate representation.
//
//   x, err := binaryProtocol.Decode(reader, wire.TStruct)
//   if err != nil {
//     return nil, err
//   }
//
//   var v SecondService_EchoBool_Result
//   if err := v.FromWire(x); err != nil {
//     return nil, err
//   }
//   return &v, nil
func (v *SecondService_EchoBool_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.TBool {
				var x bool
				x, err = field.Value.GetBool(), error(nil)
				v.Success = &x
				if err != nil {
					return err
				}

			}
		}
	}

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

	return nil
}

// String returns a readable string representation of a SecondService_EchoBool_Result
// struct.
func (v *SecondService_EchoBool_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("SecondService_EchoBool_Result{%v}", strings.Join(fields[:i], ", "))
}

func _Bool_EqualsPtr(lhs, rhs *bool) 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 SecondService_EchoBool_Result match the
// provided SecondService_EchoBool_Result.
//
// This function performs a deep comparison.
func (v *SecondService_EchoBool_Result) Equals(rhs *SecondService_EchoBool_Result) bool {
	if v == nil {
		return rhs == nil
	} else if rhs == nil {
		return false
	}
	if !_Bool_EqualsPtr(v.Success, rhs.Success) {
		return false
	}

	return true
}

// MarshalLogObject implements zapcore.ObjectMarshaler, enabling
// fast logging of SecondService_EchoBool_Result.
func (v *SecondService_EchoBool_Result) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
	if v == nil {
		return nil
	}
	if v.Success != nil {
		enc.AddBool("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 *SecondService_EchoBool_Result) GetSuccess() (o bool) {
	if v != nil && v.Success != nil {
		return *v.Success
	}

	return
}

// IsSetSuccess returns true if Success is not nil.
func (v *SecondService_EchoBool_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 "echoBool" for this struct.
func (v *SecondService_EchoBool_Result) MethodName() string {
	return "echoBool"
}

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

// SecondService_EchoDouble_Args represents the arguments for the SecondService.echoDouble function.
//
// The arguments for echoDouble are sent and received over the wire as this struct.
type SecondService_EchoDouble_Args struct {
	Arg float64 `json:"arg,required"`
}

// ToWire translates a SecondService_EchoDouble_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 *SecondService_EchoDouble_Args) ToWire() (wire.Value, error) {
	var (
		fields [1]wire.Field
		i      int = 0
		w      wire.Value
		err    error
	)

	w, err = wire.NewValueDouble(v.Arg), 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 SecondService_EchoDouble_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 SecondService_EchoDouble_Args struct
// from the provided intermediate representation.
//
//   x, err := binaryProtocol.Decode(reader, wire.TStruct)
//   if err != nil {
//     return nil, err
//   }
//
//   var v SecondService_EchoDouble_Args
//   if err := v.FromWire(x); err != nil {
//     return nil, err
//   }
//   return &v, nil
func (v *SecondService_EchoDouble_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.TDouble {
				v.Arg, err = field.Value.GetDouble(), error(nil)
				if err != nil {
					return err
				}
				argIsSet = true
			}
		}
	}

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

	return nil
}

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

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

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

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

	return true
}

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

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

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

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

// SecondService_EchoDouble_Helper provides functions that aid in handling the
// parameters and return values of the SecondService.echoDouble
// function.
var SecondService_EchoDouble_Helper = struct {
	// Args accepts the parameters of echoDouble in-order and returns
	// the arguments struct for the function.
	Args func(
		arg float64,
	) *SecondService_EchoDouble_Args

	// IsException returns true if the given error can be thrown
	// by echoDouble.
	//
	// An error can be thrown by echoDouble 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 echoDouble
	// given its return value and error.
	//
	// This allows mapping values and errors returned by
	// echoDouble into a serializable result struct.
	// WrapResponse returns a non-nil error if the provided
	// error cannot be thrown by echoDouble
	//
	//   value, err := echoDouble(args)
	//   result, err := SecondService_EchoDouble_Helper.WrapResponse(value, err)
	//   if err != nil {
	//     return fmt.Errorf("unexpected error from echoDouble: %v", err)
	//   }
	//   serialize(result)
	WrapResponse func(float64, error) (*SecondService_EchoDouble_Result, error)

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

func init() {
	SecondService_EchoDouble_Helper.Args = func(
		arg float64,
	) *SecondService_EchoDouble_Args {
		return &SecondService_EchoDouble_Args{
			Arg: arg,
		}
	}

	SecondService_EchoDouble_Helper.IsException = func(err error) bool {
		switch err.(type) {
		default:
			return false
		}
	}

	SecondService_EchoDouble_Helper.WrapResponse = func(success float64, err error) (*SecondService_EchoDouble_Result, error) {
		if err == nil {
			return &SecondService_EchoDouble_Result{Success: &success}, nil
		}

		return nil, err
	}
	SecondService_EchoDouble_Helper.UnwrapResponse = func(result *SecondService_EchoDouble_Result) (success float64, err error) {

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

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

}

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

// ToWire translates a SecondService_EchoDouble_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 *SecondService_EchoDouble_Result) ToWire() (wire.Value, error) {
	var (
		fields [1]wire.Field
		i      int = 0
		w      wire.Value
		err    error
	)

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

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

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

// FromWire deserializes a SecondService_EchoDouble_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 SecondService_EchoDouble_Result struct
// from the provided intermediate representation.
//
//   x, err := binaryProtocol.Decode(reader, wire.TStruct)
//   if err != nil {
//     return nil, err
//   }
//
//   var v SecondService_EchoDouble_Result
//   if err := v.FromWire(x); err != nil {
//     return nil, err
//   }
//   return &v, nil
func (v *SecondService_EchoDouble_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.TDouble {
				var x float64
				x, err = field.Value.GetDouble(), error(nil)
				v.Success = &x
				if err != nil {
					return err
				}

			}
		}
	}

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

	return nil
}

// String returns a readable string representation of a SecondService_EchoDouble_Result
// struct.
func (v *SecondService_EchoDouble_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("SecondService_EchoDouble_Result{%v}", strings.Join(fields[:i], ", "))
}

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

	return true
}

// MarshalLogObject implements zapcore.ObjectMarshaler, enabling
// fast logging of SecondService_EchoDouble_Result.
func (v *SecondService_EchoDouble_Result) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
	if v == nil {
		return nil
	}
	if v.Success != nil {
		enc.AddFloat64("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 *SecondService_EchoDouble_Result) GetSuccess() (o float64) {
	if v != nil && v.Success != nil {
		return *v.Success
	}

	return
}

// IsSetSuccess returns true if Success is not nil.
func (v *SecondService_EchoDouble_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 "echoDouble" for this struct.
func (v *SecondService_EchoDouble_Result) MethodName() string {
	return "echoDouble"
}

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

// SecondService_EchoEnum_Args represents the arguments for the SecondService.echoEnum function.
//
// The arguments for echoEnum are sent and received over the wire as this struct.
type SecondService_EchoEnum_Args struct {
	Arg *Fruit `json:"arg,omitempty"`
}

func _Fruit_ptr(v Fruit) *Fruit {
	return &v
}

// ToWire translates a SecondService_EchoEnum_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 *SecondService_EchoEnum_Args) ToWire() (wire.Value, error) {
	var (
		fields [1]wire.Field
		i      int = 0
		w      wire.Value
		err    error
	)

	if v.Arg == nil {
		v.Arg = _Fruit_ptr(FruitApple)
	}
	{
		w, err = v.Arg.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 _Fruit_Read(w wire.Value) (Fruit, error) {
	var v Fruit
	err := v.FromWire(w)
	return v, err
}

// FromWire deserializes a SecondService_EchoEnum_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 SecondService_EchoEnum_Args struct
// from the provided intermediate representation.
//
//   x, err := binaryProtocol.Decode(reader, wire.TStruct)
//   if err != nil {
//     return nil, err
//   }
//
//   var v SecondService_EchoEnum_Args
//   if err := v.FromWire(x); err != nil {
//     return nil, err
//   }
//   return &v, nil
func (v *SecondService_EchoEnum_Args) FromWire(w wire.Value) error {
	var err error

	for _, field := range w.GetStruct().Fields {
		switch field.ID {
		case 1:
			if field.Value.Type() == wire.TI32 {
				var x Fruit
				x, err = _Fruit_Read(field.Value)
				v.Arg = &x
				if err != nil {
					return err
				}

			}
		}
	}

	if v.Arg == nil {
		v.Arg = _Fruit_ptr(FruitApple)
	}

	return nil
}

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

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

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

func _Fruit_EqualsPtr(lhs, rhs *Fruit) bool {
	if lhs != nil && rhs != nil {

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

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

	return true
}

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

// GetArg returns the value of Arg if it is set or its
// default value if it is unset.
func (v *SecondService_EchoEnum_Args) GetArg() (o Fruit) {
	if v != nil && v.Arg != nil {
		return *v.Arg
	}
	o = FruitApple
	return
}

// IsSetArg returns true if Arg is not nil.
func (v *SecondService_EchoEnum_Args) IsSetArg() bool {
	return v != nil && v.Arg != 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 "echoEnum" for this struct.
func (v *SecondService_EchoEnum_Args) MethodName() string {
	return "echoEnum"
}

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

// SecondService_EchoEnum_Helper provides functions that aid in handling the
// parameters and return values of the SecondService.echoEnum
// function.
var SecondService_EchoEnum_Helper = struct {
	// Args accepts the parameters of echoEnum in-order and returns
	// the arguments struct for the function.
	Args func(
		arg *Fruit,
	) *SecondService_EchoEnum_Args

	// IsException returns true if the given error can be thrown
	// by echoEnum.
	//
	// An error can be thrown by echoEnum 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 echoEnum
	// given its return value and error.
	//
	// This allows mapping values and errors returned by
	// echoEnum into a serializable result struct.
	// WrapResponse returns a non-nil error if the provided
	// error cannot be thrown by echoEnum
	//
	//   value, err := echoEnum(args)
	//   result, err := SecondService_EchoEnum_Helper.WrapResponse(value, err)
	//   if err != nil {
	//     return fmt.Errorf("unexpected error from echoEnum: %v", err)
	//   }
	//   serialize(result)
	WrapResponse func(Fruit, error) (*SecondService_EchoEnum_Result, error)

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

func init() {
	SecondService_EchoEnum_Helper.Args = func(
		arg *Fruit,
	) *SecondService_EchoEnum_Args {
		return &SecondService_EchoEnum_Args{
			Arg: arg,
		}
	}

	SecondService_EchoEnum_Helper.IsException = func(err error) bool {
		switch err.(type) {
		default:
			return false
		}
	}

	SecondService_EchoEnum_Helper.WrapResponse = func(success Fruit, err error) (*SecondService_EchoEnum_Result, error) {
		if err == nil {
			return &SecondService_EchoEnum_Result{Success: &success}, nil
		}

		return nil, err
	}
	SecondService_EchoEnum_Helper.UnwrapResponse = func(result *SecondService_EchoEnum_Result) (success Fruit, err error) {

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

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

}

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

// ToWire translates a SecondService_EchoEnum_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 *SecondService_EchoEnum_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("SecondService_EchoEnum_Result should have exactly one field: got %v fields", i)
	}

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

// FromWire deserializes a SecondService_EchoEnum_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 SecondService_EchoEnum_Result struct
// from the provided intermediate representation.
//
//   x, err := binaryProtocol.Decode(reader, wire.TStruct)
//   if err != nil {
//     return nil, err
//   }
//
//   var v SecondService_EchoEnum_Result
//   if err := v.FromWire(x); err != nil {
//     return nil, err
//   }
//   return &v, nil
func (v *SecondService_EchoEnum_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.TI32 {
				var x Fruit
				x, err = _Fruit_Read(field.Value)
				v.Success = &x
				if err != nil {
					return err
				}

			}
		}
	}

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

	return nil
}

// String returns a readable string representation of a SecondService_EchoEnum_Result
// struct.
func (v *SecondService_EchoEnum_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("SecondService_EchoEnum_Result{%v}", strings.Join(fields[:i], ", "))
}

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

	return true
}

// MarshalLogObject implements zapcore.ObjectMarshaler, enabling
// fast logging of SecondService_EchoEnum_Result.
func (v *SecondService_EchoEnum_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 *SecondService_EchoEnum_Result) GetSuccess() (o Fruit) {
	if v != nil && v.Success != nil {
		return *v.Success
	}

	return
}

// IsSetSuccess returns true if Success is not nil.
func (v *SecondService_EchoEnum_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 "echoEnum" for this struct.
func (v *SecondService_EchoEnum_Result) MethodName() string {
	return "echoEnum"
}

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

// SecondService_EchoI16_Args represents the arguments for the SecondService.echoI16 function.
//
// The arguments for echoI16 are sent and received over the wire as this struct.
type SecondService_EchoI16_Args struct {
	Arg int16 `json:"arg,required"`
}

// ToWire translates a SecondService_EchoI16_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 *SecondService_EchoI16_Args) ToWire() (wire.Value, error) {
	var (
		fields [1]wire.Field
		i      int = 0
		w      wire.Value
		err    error
	)

	w, err = wire.NewValueI16(v.Arg), 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 SecondService_EchoI16_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 SecondService_EchoI16_Args struct
// from the provided intermediate representation.
//
//   x, err := binaryProtocol.Decode(reader, wire.TStruct)
//   if err != nil {
//     return nil, err
//   }
//
//   var v SecondService_EchoI16_Args
//   if err := v.FromWire(x); err != nil {
//     return nil, err
//   }
//   return &v, nil
func (v *SecondService_EchoI16_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.TI16 {
				v.Arg, err = field.Value.GetI16(), error(nil)
				if err != nil {
					return err
				}
				argIsSet = true
			}
		}
	}

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

	return nil
}

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

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

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

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

	return true
}

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

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

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

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

// SecondService_EchoI16_Helper provides functions that aid in handling the
// parameters and return values of the SecondService.echoI16
// function.
var SecondService_EchoI16_Helper = struct {
	// Args accepts the parameters of echoI16 in-order and returns
	// the arguments struct for the function.
	Args func(
		arg int16,
	) *SecondService_EchoI16_Args

	// IsException returns true if the given error can be thrown
	// by echoI16.
	//
	// An error can be thrown by echoI16 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 echoI16
	// given its return value and error.
	//
	// This allows mapping values and errors returned by
	// echoI16 into a serializable result struct.
	// WrapResponse returns a non-nil error if the provided
	// error cannot be thrown by echoI16
	//
	//   value, err := echoI16(args)
	//   result, err := SecondService_EchoI16_Helper.WrapResponse(value, err)
	//   if err != nil {
	//     return fmt.Errorf("unexpected error from echoI16: %v", err)
	//   }
	//   serialize(result)
	WrapResponse func(int16, error) (*SecondService_EchoI16_Result, error)

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

func init() {
	SecondService_EchoI16_Helper.Args = func(
		arg int16,
	) *SecondService_EchoI16_Args {
		return &SecondService_EchoI16_Args{
			Arg: arg,
		}
	}

	SecondService_EchoI16_Helper.IsException = func(err error) bool {
		switch err.(type) {
		default:
			return false
		}
	}

	SecondService_EchoI16_Helper.WrapResponse = func(success int16, err error) (*SecondService_EchoI16_Result, error) {
		if err == nil {
			return &SecondService_EchoI16_Result{Success: &success}, nil
		}

		return nil, err
	}
	SecondService_EchoI16_Helper.UnwrapResponse = func(result *SecondService_EchoI16_Result) (success int16, err error) {

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

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

}

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

// ToWire translates a SecondService_EchoI16_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 *SecondService_EchoI16_Result) ToWire() (wire.Value, error) {
	var (
		fields [1]wire.Field
		i      int = 0
		w      wire.Value
		err    error
	)

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

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

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

// FromWire deserializes a SecondService_EchoI16_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 SecondService_EchoI16_Result struct
// from the provided intermediate representation.
//
//   x, err := binaryProtocol.Decode(reader, wire.TStruct)
//   if err != nil {
//     return nil, err
//   }
//
//   var v SecondService_EchoI16_Result
//   if err := v.FromWire(x); err != nil {
//     return nil, err
//   }
//   return &v, nil
func (v *SecondService_EchoI16_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.TI16 {
				var x int16
				x, err = field.Value.GetI16(), error(nil)
				v.Success = &x
				if err != nil {
					return err
				}

			}
		}
	}

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

	return nil
}

// String returns a readable string representation of a SecondService_EchoI16_Result
// struct.
func (v *SecondService_EchoI16_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("SecondService_EchoI16_Result{%v}", strings.Join(fields[:i], ", "))
}

func _I16_EqualsPtr(lhs, rhs *int16) 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 SecondService_EchoI16_Result match the
// provided SecondService_EchoI16_Result.
//
// This function performs a deep comparison.
func (v *SecondService_EchoI16_Result) Equals(rhs *SecondService_EchoI16_Result) bool {
	if v == nil {
		return rhs == nil
	} else if rhs == nil {
		return false
	}
	if !_I16_EqualsPtr(v.Success, rhs.Success) {
		return false
	}

	return true
}

// MarshalLogObject implements zapcore.ObjectMarshaler, enabling
// fast logging of SecondService_EchoI16_Result.
func (v *SecondService_EchoI16_Result) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
	if v == nil {
		return nil
	}
	if v.Success != nil {
		enc.AddInt16("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 *SecondService_EchoI16_Result) GetSuccess() (o int16) {
	if v != nil && v.Success != nil {
		return *v.Success
	}

	return
}

// IsSetSuccess returns true if Success is not nil.
func (v *SecondService_EchoI16_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 "echoI16" for this struct.
func (v *SecondService_EchoI16_Result) MethodName() string {
	return "echoI16"
}

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

// SecondService_EchoI32_Args represents the arguments for the SecondService.echoI32 function.
//
// The arguments for echoI32 are sent and received over the wire as this struct.
type SecondService_EchoI32_Args struct {
	Arg int32 `json:"arg,required"`
}

// ToWire translates a SecondService_EchoI32_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 *SecondService_EchoI32_Args) ToWire() (wire.Value, error) {
	var (
		fields [1]wire.Field
		i      int = 0
		w      wire.Value
		err    error
	)

	w, err = wire.NewValueI32(v.Arg), 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 SecondService_EchoI32_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 SecondService_EchoI32_Args struct
// from the provided intermediate representation.
//
//   x, err := binaryProtocol.Decode(reader, wire.TStruct)
//   if err != nil {
//     return nil, err
//   }
//
//   var v SecondService_EchoI32_Args
//   if err := v.FromWire(x); err != nil {
//     return nil, err
//   }
//   return &v, nil
func (v *SecondService_EchoI32_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.TI32 {
				v.Arg, err = field.Value.GetI32(), error(nil)
				if err != nil {
					return err
				}
				argIsSet = true
			}
		}
	}

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

	return nil
}

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

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

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

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

	return true
}

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

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

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

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

// SecondService_EchoI32_Helper provides functions that aid in handling the
// parameters and return values of the SecondService.echoI32
// function.
var SecondService_EchoI32_Helper = struct {
	// Args accepts the parameters of echoI32 in-order and returns
	// the arguments struct for the function.
	Args func(
		arg int32,
	) *SecondService_EchoI32_Args

	// IsException returns true if the given error can be thrown
	// by echoI32.
	//
	// An error can be thrown by echoI32 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 echoI32
	// given its return value and error.
	//
	// This allows mapping values and errors returned by
	// echoI32 into a serializable result struct.
	// WrapResponse returns a non-nil error if the provided
	// error cannot be thrown by echoI32
	//
	//   value, err := echoI32(args)
	//   result, err := SecondService_EchoI32_Helper.WrapResponse(value, err)
	//   if err != nil {
	//     return fmt.Errorf("unexpected error from echoI32: %v", err)
	//   }
	//   serialize(result)
	WrapResponse func(int32, error) (*SecondService_EchoI32_Result, error)

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

func init() {
	SecondService_EchoI32_Helper.Args = func(
		arg int32,
	) *SecondService_EchoI32_Args {
		return &SecondService_EchoI32_Args{
			Arg: arg,
		}
	}

	SecondService_EchoI32_Helper.IsException = func(err error) bool {
		switch err.(type) {
		default:
			return false
		}
	}

	SecondService_EchoI32_Helper.WrapResponse = func(success int32, err error) (*SecondService_EchoI32_Result, error) {
		if err == nil {
			return &SecondService_EchoI32_Result{Success: &success}, nil
		}

		return nil, err
	}
	SecondService_EchoI32_Helper.UnwrapResponse = func(result *SecondService_EchoI32_Result) (success int32, err error) {

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

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

}

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

// ToWire translates a SecondService_EchoI32_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 *SecondService_EchoI32_Result) ToWire() (wire.Value, error) {
	var (
		fields [1]wire.Field
		i      int = 0
		w      wire.Value
		err    error
	)

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

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

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

// FromWire deserializes a SecondService_EchoI32_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 SecondService_EchoI32_Result struct
// from the provided intermediate representation.
//
//   x, err := binaryProtocol.Decode(reader, wire.TStruct)
//   if err != nil {
//     return nil, err
//   }
//
//   var v SecondService_EchoI32_Result
//   if err := v.FromWire(x); err != nil {
//     return nil, err
//   }
//   return &v, nil
func (v *SecondService_EchoI32_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.TI32 {
				var x int32
				x, err = field.Value.GetI32(), error(nil)
				v.Success = &x
				if err != nil {
					return err
				}

			}
		}
	}

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

	return nil
}

// String returns a readable string representation of a SecondService_EchoI32_Result
// struct.
func (v *SecondService_EchoI32_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("SecondService_EchoI32_Result{%v}", strings.Join(fields[:i], ", "))
}

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

	return true
}

// MarshalLogObject implements zapcore.ObjectMarshaler, enabling
// fast logging of SecondService_EchoI32_Result.
func (v *SecondService_EchoI32_Result) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
	if v == nil {
		return nil
	}
	if v.Success != nil {
		enc.AddInt32("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 *SecondService_EchoI32_Result) GetSuccess() (o int32) {
	if v != nil && v.Success != nil {
		return *v.Success
	}

	return
}

// IsSetSuccess returns true if Success is not nil.
func (v *SecondService_EchoI32_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 "echoI32" for this struct.
func (v *SecondService_EchoI32_Result) MethodName() string {
	return "echoI32"
}

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

// SecondService_EchoI64_Args represents the arguments for the SecondService.echoI64 function.
//
// The arguments for echoI64 are sent and received over the wire as this struct.
type SecondService_EchoI64_Args struct {
	Arg int64 `json:"arg,required"`
}

// ToWire translates a SecondService_EchoI64_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 *SecondService_EchoI64_Args) ToWire() (wire.Value, error) {
	var (
		fields [1]wire.Field
		i      int = 0
		w      wire.Value
		err    error
	)

	w, err = wire.NewValueI64(v.Arg), 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 SecondService_EchoI64_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 SecondService_EchoI64_Args struct
// from the provided intermediate representation.
//
//   x, err := binaryProtocol.Decode(reader, wire.TStruct)
//   if err != nil {
//     return nil, err
//   }
//
//   var v SecondService_EchoI64_Args
//   if err := v.FromWire(x); err != nil {
//     return nil, err
//   }
//   return &v, nil
func (v *SecondService_EchoI64_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.TI64 {
				v.Arg, err = field.Value.GetI64(), error(nil)
				if err != nil {
					return err
				}
				argIsSet = true
			}
		}
	}

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

	return nil
}

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

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

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

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

	return true
}

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

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

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

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

// SecondService_EchoI64_Helper provides functions that aid in handling the
// parameters and return values of the SecondService.echoI64
// function.
var SecondService_EchoI64_Helper = struct {
	// Args accepts the parameters of echoI64 in-order and returns
	// the arguments struct for the function.
	Args func(
		arg int64,
	) *SecondService_EchoI64_Args

	// IsException returns true if the given error can be thrown
	// by echoI64.
	//
	// An error can be thrown by echoI64 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 echoI64
	// given its return value and error.
	//
	// This allows mapping values and errors returned by
	// echoI64 into a serializable result struct.
	// WrapResponse returns a non-nil error if the provided
	// error cannot be thrown by echoI64
	//
	//   value, err := echoI64(args)
	//   result, err := SecondService_EchoI64_Helper.WrapResponse(value, err)
	//   if err != nil {
	//     return fmt.Errorf("unexpected error from echoI64: %v", err)
	//   }
	//   serialize(result)
	WrapResponse func(int64, error) (*SecondService_EchoI64_Result, error)

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

func init() {
	SecondService_EchoI64_Helper.Args = func(
		arg int64,
	) *SecondService_EchoI64_Args {
		return &SecondService_EchoI64_Args{
			Arg: arg,
		}
	}

	SecondService_EchoI64_Helper.IsException = func(err error) bool {
		switch err.(type) {
		default:
			return false
		}
	}

	SecondService_EchoI64_Helper.WrapResponse = func(success int64, err error) (*SecondService_EchoI64_Result, error) {
		if err == nil {
			return &SecondService_EchoI64_Result{Success: &success}, nil
		}

		return nil, err
	}
	SecondService_EchoI64_Helper.UnwrapResponse = func(result *SecondService_EchoI64_Result) (success int64, err error) {

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

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

}

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

// ToWire translates a SecondService_EchoI64_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 *SecondService_EchoI64_Result) ToWire() (wire.Value, error) {
	var (
		fields [1]wire.Field
		i      int = 0
		w      wire.Value
		err    error
	)

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

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

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

// FromWire deserializes a SecondService_EchoI64_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 SecondService_EchoI64_Result struct
// from the provided intermediate representation.
//
//   x, err := binaryProtocol.Decode(reader, wire.TStruct)
//   if err != nil {
//     return nil, err
//   }
//
//   var v SecondService_EchoI64_Result
//   if err := v.FromWire(x); err != nil {
//     return nil, err
//   }
//   return &v, nil
func (v *SecondService_EchoI64_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.TI64 {
				var x int64
				x, err = field.Value.GetI64(), error(nil)
				v.Success = &x
				if err != nil {
					return err
				}

			}
		}
	}

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

	return nil
}

// String returns a readable string representation of a SecondService_EchoI64_Result
// struct.
func (v *SecondService_EchoI64_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("SecondService_EchoI64_Result{%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
}

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

	return true
}

// MarshalLogObject implements zapcore.ObjectMarshaler, enabling
// fast logging of SecondService_EchoI64_Result.
func (v *SecondService_EchoI64_Result) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
	if v == nil {
		return nil
	}
	if v.Success != nil {
		enc.AddInt64("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 *SecondService_EchoI64_Result) GetSuccess() (o int64) {
	if v != nil && v.Success != nil {
		return *v.Success
	}

	return
}

// IsSetSuccess returns true if Success is not nil.
func (v *SecondService_EchoI64_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 "echoI64" for this struct.
func (v *SecondService_EchoI64_Result) MethodName() string {
	return "echoI64"
}

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

// SecondService_EchoI8_Args represents the arguments for the SecondService.echoI8 function.
//
// The arguments for echoI8 are sent and received over the wire as this struct.
type SecondService_EchoI8_Args struct {
	Arg int8 `json:"arg,required"`
}

// ToWire translates a SecondService_EchoI8_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 *SecondService_EchoI8_Args) ToWire() (wire.Value, error) {
	var (
		fields [1]wire.Field
		i      int = 0
		w      wire.Value
		err    error
	)

	w, err = wire.NewValueI8(v.Arg), 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 SecondService_EchoI8_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 SecondService_EchoI8_Args struct
// from the provided intermediate representation.
//
//   x, err := binaryProtocol.Decode(reader, wire.TStruct)
//   if err != nil {
//     return nil, err
//   }
//
//   var v SecondService_EchoI8_Args
//   if err := v.FromWire(x); err != nil {
//     return nil, err
//   }
//   return &v, nil
func (v *SecondService_EchoI8_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.TI8 {
				v.Arg, err = field.Value.GetI8(), error(nil)
				if err != nil {
					return err
				}
				argIsSet = true
			}
		}
	}

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

	return nil
}

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

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

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

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

	return true
}

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

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

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

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

// SecondService_EchoI8_Helper provides functions that aid in handling the
// parameters and return values of the SecondService.echoI8
// function.
var SecondService_EchoI8_Helper = struct {
	// Args accepts the parameters of echoI8 in-order and returns
	// the arguments struct for the function.
	Args func(
		arg int8,
	) *SecondService_EchoI8_Args

	// IsException returns true if the given error can be thrown
	// by echoI8.
	//
	// An error can be thrown by echoI8 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 echoI8
	// given its return value and error.
	//
	// This allows mapping values and errors returned by
	// echoI8 into a serializable result struct.
	// WrapResponse returns a non-nil error if the provided
	// error cannot be thrown by echoI8
	//
	//   value, err := echoI8(args)
	//   result, err := SecondService_EchoI8_Helper.WrapResponse(value, err)
	//   if err != nil {
	//     return fmt.Errorf("unexpected error from echoI8: %v", err)
	//   }
	//   serialize(result)
	WrapResponse func(int8, error) (*SecondService_EchoI8_Result, error)

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

func init() {
	SecondService_EchoI8_Helper.Args = func(
		arg int8,
	) *SecondService_EchoI8_Args {
		return &SecondService_EchoI8_Args{
			Arg: arg,
		}
	}

	SecondService_EchoI8_Helper.IsException = func(err error) bool {
		switch err.(type) {
		default:
			return false
		}
	}

	SecondService_EchoI8_Helper.WrapResponse = func(success int8, err error) (*SecondService_EchoI8_Result, error) {
		if err == nil {
			return &SecondService_EchoI8_Result{Success: &success}, nil
		}

		return nil, err
	}
	SecondService_EchoI8_Helper.UnwrapResponse = func(result *SecondService_EchoI8_Result) (success int8, err error) {

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

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

}

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

// ToWire translates a SecondService_EchoI8_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 *SecondService_EchoI8_Result) ToWire() (wire.Value, error) {
	var (
		fields [1]wire.Field
		i      int = 0
		w      wire.Value
		err    error
	)

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

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

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

// FromWire deserializes a SecondService_EchoI8_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 SecondService_EchoI8_Result struct
// from the provided intermediate representation.
//
//   x, err := binaryProtocol.Decode(reader, wire.TStruct)
//   if err != nil {
//     return nil, err
//   }
//
//   var v SecondService_EchoI8_Result
//   if err := v.FromWire(x); err != nil {
//     return nil, err
//   }
//   return &v, nil
func (v *SecondService_EchoI8_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.TI8 {
				var x int8
				x, err = field.Value.GetI8(), error(nil)
				v.Success = &x
				if err != nil {
					return err
				}

			}
		}
	}

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

	return nil
}

// String returns a readable string representation of a SecondService_EchoI8_Result
// struct.
func (v *SecondService_EchoI8_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("SecondService_EchoI8_Result{%v}", strings.Join(fields[:i], ", "))
}

func _Byte_EqualsPtr(lhs, rhs *int8) 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 SecondService_EchoI8_Result match the
// provided SecondService_EchoI8_Result.
//
// This function performs a deep comparison.
func (v *SecondService_EchoI8_Result) Equals(rhs *SecondService_EchoI8_Result) bool {
	if v == nil {
		return rhs == nil
	} else if rhs == nil {
		return false
	}
	if !_Byte_EqualsPtr(v.Success, rhs.Success) {
		return false
	}

	return true
}

// MarshalLogObject implements zapcore.ObjectMarshaler, enabling
// fast logging of SecondService_EchoI8_Result.
func (v *SecondService_EchoI8_Result) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
	if v == nil {
		return nil
	}
	if v.Success != nil {
		enc.AddInt8("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 *SecondService_EchoI8_Result) GetSuccess() (o int8) {
	if v != nil && v.Success != nil {
		return *v.Success
	}

	return
}

// IsSetSuccess returns true if Success is not nil.
func (v *SecondService_EchoI8_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 "echoI8" for this struct.
func (v *SecondService_EchoI8_Result) MethodName() string {
	return "echoI8"
}

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

// SecondService_EchoString_Args represents the arguments for the SecondService.echoString function.
//
// The arguments for echoString are sent and received over the wire as this struct.
type SecondService_EchoString_Args struct {
	Arg string `json:"arg,required"`
}

// ToWire translates a SecondService_EchoString_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 *SecondService_EchoString_Args) ToWire() (wire.Value, error) {
	var (
		fields [1]wire.Field
		i      int = 0
		w      wire.Value
		err    error
	)

	w, err = wire.NewValueString(v.Arg), 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 SecondService_EchoString_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 SecondService_EchoString_Args struct
// from the provided intermediate representation.
//
//   x, err := binaryProtocol.Decode(reader, wire.TStruct)
//   if err != nil {
//     return nil, err
//   }
//
//   var v SecondService_EchoString_Args
//   if err := v.FromWire(x); err != nil {
//     return nil, err
//   }
//   return &v, nil
func (v *SecondService_EchoString_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.TBinary {
				v.Arg, err = field.Value.GetString(), error(nil)
				if err != nil {
					return err
				}
				argIsSet = true
			}
		}
	}

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

	return nil
}

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

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

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

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

	return true
}

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

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

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

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

// SecondService_EchoString_Helper provides functions that aid in handling the
// parameters and return values of the SecondService.echoString
// function.
var SecondService_EchoString_Helper = struct {
	// Args accepts the parameters of echoString in-order and returns
	// the arguments struct for the function.
	Args func(
		arg string,
	) *SecondService_EchoString_Args

	// IsException returns true if the given error can be thrown
	// by echoString.
	//
	// An error can be thrown by echoString 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 echoString
	// given its return value and error.
	//
	// This allows mapping values and errors returned by
	// echoString into a serializable result struct.
	// WrapResponse returns a non-nil error if the provided
	// error cannot be thrown by echoString
	//
	//   value, err := echoString(args)
	//   result, err := SecondService_EchoString_Helper.WrapResponse(value, err)
	//   if err != nil {
	//     return fmt.Errorf("unexpected error from echoString: %v", err)
	//   }
	//   serialize(result)
	WrapResponse func(string, error) (*SecondService_EchoString_Result, error)

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

func init() {
	SecondService_EchoString_Helper.Args = func(
		arg string,
	) *SecondService_EchoString_Args {
		return &SecondService_EchoString_Args{
			Arg: arg,
		}
	}

	SecondService_EchoString_Helper.IsException = func(err error) bool {
		switch err.(type) {
		default:
			return false
		}
	}

	SecondService_EchoString_Helper.WrapResponse = func(success string, err error) (*SecondService_EchoString_Result, error) {
		if err == nil {
			return &SecondService_EchoString_Result{Success: &success}, nil
		}

		return nil, err
	}
	SecondService_EchoString_Helper.UnwrapResponse = func(result *SecondService_EchoString_Result) (success string, err error) {

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

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

}

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

// ToWire translates a SecondService_EchoString_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 *SecondService_EchoString_Result) ToWire() (wire.Value, error) {
	var (
		fields [1]wire.Field
		i      int = 0
		w      wire.Value
		err    error
	)

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

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

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

// FromWire deserializes a SecondService_EchoString_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 SecondService_EchoString_Result struct
// from the provided intermediate representation.
//
//   x, err := binaryProtocol.Decode(reader, wire.TStruct)
//   if err != nil {
//     return nil, err
//   }
//
//   var v SecondService_EchoString_Result
//   if err := v.FromWire(x); err != nil {
//     return nil, err
//   }
//   return &v, nil
func (v *SecondService_EchoString_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.TBinary {
				var x string
				x, err = field.Value.GetString(), error(nil)
				v.Success = &x
				if err != nil {
					return err
				}

			}
		}
	}

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

	return nil
}

// String returns a readable string representation of a SecondService_EchoString_Result
// struct.
func (v *SecondService_EchoString_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("SecondService_EchoString_Result{%v}", strings.Join(fields[:i], ", "))
}

func _String_EqualsPtr(lhs, rhs *string) 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 SecondService_EchoString_Result match the
// provided SecondService_EchoString_Result.
//
// This function performs a deep comparison.
func (v *SecondService_EchoString_Result) Equals(rhs *SecondService_EchoString_Result) bool {
	if v == nil {
		return rhs == nil
	} else if rhs == nil {
		return false
	}
	if !_String_EqualsPtr(v.Success, rhs.Success) {
		return false
	}

	return true
}

// MarshalLogObject implements zapcore.ObjectMarshaler, enabling
// fast logging of SecondService_EchoString_Result.
func (v *SecondService_EchoString_Result) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
	if v == nil {
		return nil
	}
	if v.Success != nil {
		enc.AddString("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 *SecondService_EchoString_Result) GetSuccess() (o string) {
	if v != nil && v.Success != nil {
		return *v.Success
	}

	return
}

// IsSetSuccess returns true if Success is not nil.
func (v *SecondService_EchoString_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 "echoString" for this struct.
func (v *SecondService_EchoString_Result) MethodName() string {
	return "echoString"
}

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

// SecondService_EchoStringList_Args represents the arguments for the SecondService.echoStringList function.
//
// The arguments for echoStringList are sent and received over the wire as this struct.
type SecondService_EchoStringList_Args struct {
	Arg []string `json:"arg,required"`
}

type _List_String_ValueList []string

func (v _List_String_ValueList) ForEach(f func(wire.Value) error) error {
	for _, x := range v {
		w, err := wire.NewValueString(x), error(nil)
		if err != nil {
			return err
		}
		err = f(w)
		if err != nil {
			return err
		}
	}
	return nil
}

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

func (_List_String_ValueList) ValueType() wire.Type {
	return wire.TBinary
}

func (_List_String_ValueList) Close() {}

// ToWire translates a SecondService_EchoStringList_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 *SecondService_EchoStringList_Args) ToWire() (wire.Value, error) {
	var (
		fields [1]wire.Field
		i      int = 0
		w      wire.Value
		err    error
	)

	w, err = wire.NewValueList(_List_String_ValueList(v.Arg)), 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 _List_String_Read(l wire.ValueList) ([]string, error) {
	if l.ValueType() != wire.TBinary {
		return nil, nil
	}

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

// FromWire deserializes a SecondService_EchoStringList_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 SecondService_EchoStringList_Args struct
// from the provided intermediate representation.
//
//   x, err := binaryProtocol.Decode(reader, wire.TStruct)
//   if err != nil {
//     return nil, err
//   }
//
//   var v SecondService_EchoStringList_Args
//   if err := v.FromWire(x); err != nil {
//     return nil, err
//   }
//   return &v, nil
func (v *SecondService_EchoStringList_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.TList {
				v.Arg, err = _List_String_Read(field.Value.GetList())
				if err != nil {
					return err
				}
				argIsSet = true
			}
		}
	}

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

	return nil
}

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

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

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

func _List_String_Equals(lhs, rhs []string) bool {
	if len(lhs) != len(rhs) {
		return false
	}

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

	return true
}

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

	return true
}

type _List_String_Zapper []string

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

// MarshalLogObject implements zapcore.ObjectMarshaler, enabling
// fast logging of SecondService_EchoStringList_Args.
func (v *SecondService_EchoStringList_Args) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
	if v == nil {
		return nil
	}
	err = multierr.Append(err, enc.AddArray("arg", (_List_String_Zapper)(v.Arg)))
	return err
}

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

// IsSetArg returns true if Arg is not nil.
func (v *SecondService_EchoStringList_Args) IsSetArg() bool {
	return v != nil && v.Arg != 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 "echoStringList" for this struct.
func (v *SecondService_EchoStringList_Args) MethodName() string {
	return "echoStringList"
}

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

// SecondService_EchoStringList_Helper provides functions that aid in handling the
// parameters and return values of the SecondService.echoStringList
// function.
var SecondService_EchoStringList_Helper = struct {
	// Args accepts the parameters of echoStringList in-order and returns
	// the arguments struct for the function.
	Args func(
		arg []string,
	) *SecondService_EchoStringList_Args

	// IsException returns true if the given error can be thrown
	// by echoStringList.
	//
	// An error can be thrown by echoStringList 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 echoStringList
	// given its return value and error.
	//
	// This allows mapping values and errors returned by
	// echoStringList into a serializable result struct.
	// WrapResponse returns a non-nil error if the provided
	// error cannot be thrown by echoStringList
	//
	//   value, err := echoStringList(args)
	//   result, err := SecondService_EchoStringList_Helper.WrapResponse(value, err)
	//   if err != nil {
	//     return fmt.Errorf("unexpected error from echoStringList: %v", err)
	//   }
	//   serialize(result)
	WrapResponse func([]string, error) (*SecondService_EchoStringList_Result, error)

	// UnwrapResponse takes the result struct for echoStringList
	// and returns the value or error returned by it.
	//
	// The error is non-nil only if echoStringList threw an
	// exception.
	//
	//   result := deserialize(bytes)
	//   value, err := SecondService_EchoStringList_Helper.UnwrapResponse(result)
	UnwrapResponse func(*SecondService_EchoStringList_Result) ([]string, error)
}{}

func init() {
	SecondService_EchoStringList_Helper.Args = func(
		arg []string,
	) *SecondService_EchoStringList_Args {
		return &SecondService_EchoStringList_Args{
			Arg: arg,
		}
	}

	SecondService_EchoStringList_Helper.IsException = func(err error) bool {
		switch err.(type) {
		default:
			return false
		}
	}

	SecondService_EchoStringList_Helper.WrapResponse = func(success []string, err error) (*SecondService_EchoStringList_Result, error) {
		if err == nil {
			return &SecondService_EchoStringList_Result{Success: success}, nil
		}

		return nil, err
	}
	SecondService_EchoStringList_Helper.UnwrapResponse = func(result *SecondService_EchoStringList_Result) (success []string, err error) {

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

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

}

// SecondService_EchoStringList_Result represents the result of a SecondService.echoStringList function call.
//
// The result of a echoStringList execution is sent and received over the wire as this struct.
//
// Success is set only if the function did not throw an exception.
type SecondService_EchoStringList_Result struct {
	// Value returned by echoStringList after a successful execution.
	Success []string `json:"success,omitempty"`
}

// ToWire translates a SecondService_EchoStringList_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 *SecondService_EchoStringList_Result) ToWire() (wire.Value, error) {
	var (
		fields [1]wire.Field
		i      int = 0
		w      wire.Value
		err    error
	)

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

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

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

// FromWire deserializes a SecondService_EchoStringList_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 SecondService_EchoStringList_Result struct
// from the provided intermediate representation.
//
//   x, err := binaryProtocol.Decode(reader, wire.TStruct)
//   if err != nil {
//     return nil, err
//   }
//
//   var v SecondService_EchoStringList_Result
//   if err := v.FromWire(x); err != nil {
//     return nil, err
//   }
//   return &v, nil
func (v *SecondService_EchoStringList_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.TList {
				v.Success, err = _List_String_Read(field.Value.GetList())
				if err != nil {
					return err
				}

			}
		}
	}

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

	return nil
}

// String returns a readable string representation of a SecondService_EchoStringList_Result
// struct.
func (v *SecondService_EchoStringList_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("SecondService_EchoStringList_Result{%v}", strings.Join(fields[:i], ", "))
}

// Equals returns true if all the fields of this SecondService_EchoStringList_Result match the
// provided SecondService_EchoStringList_Result.
//
// This function performs a deep comparison.
func (v *SecondService_EchoStringList_Result) Equals(rhs *SecondService_EchoStringList_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 && _List_String_Equals(v.Success, rhs.Success))) {
		return false
	}

	return true
}

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

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

	return
}

// IsSetSuccess returns true if Success is not nil.
func (v *SecondService_EchoStringList_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 "echoStringList" for this struct.
func (v *SecondService_EchoStringList_Result) MethodName() string {
	return "echoStringList"
}

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

// SecondService_EchoStringMap_Args represents the arguments for the SecondService.echoStringMap function.
//
// The arguments for echoStringMap are sent and received over the wire as this struct.
type SecondService_EchoStringMap_Args struct {
	Arg map[string]*base.BazResponse `json:"arg,required"`
}

type _Map_String_BazResponse_MapItemList map[string]*base.BazResponse

func (m _Map_String_BazResponse_MapItemList) ForEach(f func(wire.MapItem) error) error {
	for k, v := range m {
		if v == nil {
			return fmt.Errorf("invalid [%v]: value is nil", k)
		}
		kw, err := wire.NewValueString(k), error(nil)
		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_String_BazResponse_MapItemList) Size() int {
	return len(m)
}

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

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

func (_Map_String_BazResponse_MapItemList) Close() {}

// ToWire translates a SecondService_EchoStringMap_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 *SecondService_EchoStringMap_Args) ToWire() (wire.Value, error) {
	var (
		fields [1]wire.Field
		i      int = 0
		w      wire.Value
		err    error
	)

	if v.Arg == nil {
		return w, errors.New("field Arg of SecondService_EchoStringMap_Args is required")
	}
	w, err = wire.NewValueMap(_Map_String_BazResponse_MapItemList(v.Arg)), 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 _BazResponse_Read(w wire.Value) (*base.BazResponse, error) {
	var v base.BazResponse
	err := v.FromWire(w)
	return &v, err
}

func _Map_String_BazResponse_Read(m wire.MapItemList) (map[string]*base.BazResponse, error) {
	if m.KeyType() != wire.TBinary {
		return nil, nil
	}

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

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

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

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

// FromWire deserializes a SecondService_EchoStringMap_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 SecondService_EchoStringMap_Args struct
// from the provided intermediate representation.
//
//   x, err := binaryProtocol.Decode(reader, wire.TStruct)
//   if err != nil {
//     return nil, err
//   }
//
//   var v SecondService_EchoStringMap_Args
//   if err := v.FromWire(x); err != nil {
//     return nil, err
//   }
//   return &v, nil
func (v *SecondService_EchoStringMap_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.TMap {
				v.Arg, err = _Map_String_BazResponse_Read(field.Value.GetMap())
				if err != nil {
					return err
				}
				argIsSet = true
			}
		}
	}

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

	return nil
}

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

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

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

func _Map_String_BazResponse_Equals(lhs, rhs map[string]*base.BazResponse) 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 SecondService_EchoStringMap_Args match the
// provided SecondService_EchoStringMap_Args.
//
// This function performs a deep comparison.
func (v *SecondService_EchoStringMap_Args) Equals(rhs *SecondService_EchoStringMap_Args) bool {
	if v == nil {
		return rhs == nil
	} else if rhs == nil {
		return false
	}
	if !_Map_String_BazResponse_Equals(v.Arg, rhs.Arg) {
		return false
	}

	return true
}

type _Map_String_BazResponse_Zapper map[string]*base.BazResponse

// MarshalLogObject implements zapcore.ObjectMarshaler, enabling
// fast logging of _Map_String_BazResponse_Zapper.
func (m _Map_String_BazResponse_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 SecondService_EchoStringMap_Args.
func (v *SecondService_EchoStringMap_Args) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
	if v == nil {
		return nil
	}
	err = multierr.Append(err, enc.AddObject("arg", (_Map_String_BazResponse_Zapper)(v.Arg)))
	return err
}

// GetArg returns the value of Arg if it is set or its
// zero value if it is unset.
func (v *SecondService_EchoStringMap_Args) GetArg() (o map[string]*base.BazResponse) {
	if v != nil {
		o = v.Arg
	}
	return
}

// IsSetArg returns true if Arg is not nil.
func (v *SecondService_EchoStringMap_Args) IsSetArg() bool {
	return v != nil && v.Arg != 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 "echoStringMap" for this struct.
func (v *SecondService_EchoStringMap_Args) MethodName() string {
	return "echoStringMap"
}

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

// SecondService_EchoStringMap_Helper provides functions that aid in handling the
// parameters and return values of the SecondService.echoStringMap
// function.
var SecondService_EchoStringMap_Helper = struct {
	// Args accepts the parameters of echoStringMap in-order and returns
	// the arguments struct for the function.
	Args func(
		arg map[string]*base.BazResponse,
	) *SecondService_EchoStringMap_Args

	// IsException returns true if the given error can be thrown
	// by echoStringMap.
	//
	// An error can be thrown by echoStringMap 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 echoStringMap
	// given its return value and error.
	//
	// This allows mapping values and errors returned by
	// echoStringMap into a serializable result struct.
	// WrapResponse returns a non-nil error if the provided
	// error cannot be thrown by echoStringMap
	//
	//   value, err := echoStringMap(args)
	//   result, err := SecondService_EchoStringMap_Helper.WrapResponse(value, err)
	//   if err != nil {
	//     return fmt.Errorf("unexpected error from echoStringMap: %v", err)
	//   }
	//   serialize(result)
	WrapResponse func(map[string]*base.BazResponse, error) (*SecondService_EchoStringMap_Result, error)

	// UnwrapResponse takes the result struct for echoStringMap
	// and returns the value or error returned by it.
	//
	// The error is non-nil only if echoStringMap threw an
	// exception.
	//
	//   result := deserialize(bytes)
	//   value, err := SecondService_EchoStringMap_Helper.UnwrapResponse(result)
	UnwrapResponse func(*SecondService_EchoStringMap_Result) (map[string]*base.BazResponse, error)
}{}

func init() {
	SecondService_EchoStringMap_Helper.Args = func(
		arg map[string]*base.BazResponse,
	) *SecondService_EchoStringMap_Args {
		return &SecondService_EchoStringMap_Args{
			Arg: arg,
		}
	}

	SecondService_EchoStringMap_Helper.IsException = func(err error) bool {
		switch err.(type) {
		default:
			return false
		}
	}

	SecondService_EchoStringMap_Helper.WrapResponse = func(success map[string]*base.BazResponse, err error) (*SecondService_EchoStringMap_Result, error) {
		if err == nil {
			return &SecondService_EchoStringMap_Result{Success: success}, nil
		}

		return nil, err
	}
	SecondService_EchoStringMap_Helper.UnwrapResponse = func(result *SecondService_EchoStringMap_Result) (success map[string]*base.BazResponse, err error) {

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

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

}

// SecondService_EchoStringMap_Result represents the result of a SecondService.echoStringMap function call.
//
// The result of a echoStringMap execution is sent and received over the wire as this struct.
//
// Success is set only if the function did not throw an exception.
type SecondService_EchoStringMap_Result struct {
	// Value returned by echoStringMap after a successful execution.
	Success map[string]*base.BazResponse `json:"success,omitempty"`
}

// ToWire translates a SecondService_EchoStringMap_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 *SecondService_EchoStringMap_Result) ToWire() (wire.Value, error) {
	var (
		fields [1]wire.Field
		i      int = 0
		w      wire.Value
		err    error
	)

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

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

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

// FromWire deserializes a SecondService_EchoStringMap_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 SecondService_EchoStringMap_Result struct
// from the provided intermediate representation.
//
//   x, err := binaryProtocol.Decode(reader, wire.TStruct)
//   if err != nil {
//     return nil, err
//   }
//
//   var v SecondService_EchoStringMap_Result
//   if err := v.FromWire(x); err != nil {
//     return nil, err
//   }
//   return &v, nil
func (v *SecondService_EchoStringMap_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.TMap {
				v.Success, err = _Map_String_BazResponse_Read(field.Value.GetMap())
				if err != nil {
					return err
				}

			}
		}
	}

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

	return nil
}

// String returns a readable string representation of a SecondService_EchoStringMap_Result
// struct.
func (v *SecondService_EchoStringMap_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("SecondService_EchoStringMap_Result{%v}", strings.Join(fields[:i], ", "))
}

// Equals returns true if all the fields of this SecondService_EchoStringMap_Result match the
// provided SecondService_EchoStringMap_Result.
//
// This function performs a deep comparison.
func (v *SecondService_EchoStringMap_Result) Equals(rhs *SecondService_EchoStringMap_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 && _Map_String_BazResponse_Equals(v.Success, rhs.Success))) {
		return false
	}

	return true
}

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

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

	return
}

// IsSetSuccess returns true if Success is not nil.
func (v *SecondService_EchoStringMap_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 "echoStringMap" for this struct.
func (v *SecondService_EchoStringMap_Result) MethodName() string {
	return "echoStringMap"
}

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

// SecondService_EchoStringSet_Args represents the arguments for the SecondService.echoStringSet function.
//
// The arguments for echoStringSet are sent and received over the wire as this struct.
type SecondService_EchoStringSet_Args struct {
	Arg map[string]struct{} `json:"arg,required"`
}

type _Set_String_mapType_ValueList map[string]struct{}

func (v _Set_String_mapType_ValueList) ForEach(f func(wire.Value) error) error {
	for x := range v {
		w, err := wire.NewValueString(x), error(nil)
		if err != nil {
			return err
		}

		if err := f(w); err != nil {
			return err
		}
	}
	return nil
}

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

func (_Set_String_mapType_ValueList) ValueType() wire.Type {
	return wire.TBinary
}

func (_Set_String_mapType_ValueList) Close() {}

// ToWire translates a SecondService_EchoStringSet_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 *SecondService_EchoStringSet_Args) ToWire() (wire.Value, error) {
	var (
		fields [1]wire.Field
		i      int = 0
		w      wire.Value
		err    error
	)

	if v.Arg == nil {
		return w, errors.New("field Arg of SecondService_EchoStringSet_Args is required")
	}
	w, err = wire.NewValueSet(_Set_String_mapType_ValueList(v.Arg)), 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 _Set_String_mapType_Read(s wire.ValueList) (map[string]struct{}, error) {
	if s.ValueType() != wire.TBinary {
		return nil, nil
	}

	o := make(map[string]struct{}, s.Size())
	err := s.ForEach(func(x wire.Value) error {
		i, err := x.GetString(), error(nil)
		if err != nil {
			return err
		}

		o[i] = struct{}{}
		return nil
	})
	s.Close()
	return o, err
}

// FromWire deserializes a SecondService_EchoStringSet_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 SecondService_EchoStringSet_Args struct
// from the provided intermediate representation.
//
//   x, err := binaryProtocol.Decode(reader, wire.TStruct)
//   if err != nil {
//     return nil, err
//   }
//
//   var v SecondService_EchoStringSet_Args
//   if err := v.FromWire(x); err != nil {
//     return nil, err
//   }
//   return &v, nil
func (v *SecondService_EchoStringSet_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.TSet {
				v.Arg, err = _Set_String_mapType_Read(field.Value.GetSet())
				if err != nil {
					return err
				}
				argIsSet = true
			}
		}
	}

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

	return nil
}

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

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

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

func _Set_String_mapType_Equals(lhs, rhs map[string]struct{}) bool {
	if len(lhs) != len(rhs) {
		return false
	}

	for x := range rhs {
		if _, ok := lhs[x]; !ok {
			return false
		}
	}

	return true
}

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

	return true
}

type _Set_String_mapType_Zapper map[string]struct{}

// MarshalLogArray implements zapcore.ArrayMarshaler, enabling
// fast logging of _Set_String_mapType_Zapper.
func (s _Set_String_mapType_Zapper) MarshalLogArray(enc zapcore.ArrayEncoder) (err error) {
	for v := range s {
		enc.AppendString(v)
	}
	return err
}

// MarshalLogObject implements zapcore.ObjectMarshaler, enabling
// fast logging of SecondService_EchoStringSet_Args.
func (v *SecondService_EchoStringSet_Args) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
	if v == nil {
		return nil
	}
	err = multierr.Append(err, enc.AddArray("arg", (_Set_String_mapType_Zapper)(v.Arg)))
	return err
}

// GetArg returns the value of Arg if it is set or its
// zero value if it is unset.
func (v *SecondService_EchoStringSet_Args) GetArg() (o map[string]struct{}) {
	if v != nil {
		o = v.Arg
	}
	return
}

// IsSetArg returns true if Arg is not nil.
func (v *SecondService_EchoStringSet_Args) IsSetArg() bool {
	return v != nil && v.Arg != 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 "echoStringSet" for this struct.
func (v *SecondService_EchoStringSet_Args) MethodName() string {
	return "echoStringSet"
}

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

// SecondService_EchoStringSet_Helper provides functions that aid in handling the
// parameters and return values of the SecondService.echoStringSet
// function.
var SecondService_EchoStringSet_Helper = struct {
	// Args accepts the parameters of echoStringSet in-order and returns
	// the arguments struct for the function.
	Args func(
		arg map[string]struct{},
	) *SecondService_EchoStringSet_Args

	// IsException returns true if the given error can be thrown
	// by echoStringSet.
	//
	// An error can be thrown by echoStringSet 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 echoStringSet
	// given its return value and error.
	//
	// This allows mapping values and errors returned by
	// echoStringSet into a serializable result struct.
	// WrapResponse returns a non-nil error if the provided
	// error cannot be thrown by echoStringSet
	//
	//   value, err := echoStringSet(args)
	//   result, err := SecondService_EchoStringSet_Helper.WrapResponse(value, err)
	//   if err != nil {
	//     return fmt.Errorf("unexpected error from echoStringSet: %v", err)
	//   }
	//   serialize(result)
	WrapResponse func(map[string]struct{}, error) (*SecondService_EchoStringSet_Result, error)

	// UnwrapResponse takes the result struct for echoStringSet
	// and returns the value or error returned by it.
	//
	// The error is non-nil only if echoStringSet threw an
	// exception.
	//
	//   result := deserialize(bytes)
	//   value, err := SecondService_EchoStringSet_Helper.UnwrapResponse(result)
	UnwrapResponse func(*SecondService_EchoStringSet_Result) (map[string]struct{}, error)
}{}

func init() {
	SecondService_EchoStringSet_Helper.Args = func(
		arg map[string]struct{},
	) *SecondService_EchoStringSet_Args {
		return &SecondService_EchoStringSet_Args{
			Arg: arg,
		}
	}

	SecondService_EchoStringSet_Helper.IsException = func(err error) bool {
		switch err.(type) {
		default:
			return false
		}
	}

	SecondService_EchoStringSet_Helper.WrapResponse = func(success map[string]struct{}, err error) (*SecondService_EchoStringSet_Result, error) {
		if err == nil {
			return &SecondService_EchoStringSet_Result{Success: success}, nil
		}

		return nil, err
	}
	SecondService_EchoStringSet_Helper.UnwrapResponse = func(result *SecondService_EchoStringSet_Result) (success map[string]struct{}, err error) {

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

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

}

// SecondService_EchoStringSet_Result represents the result of a SecondService.echoStringSet function call.
//
// The result of a echoStringSet execution is sent and received over the wire as this struct.
//
// Success is set only if the function did not throw an exception.
type SecondService_EchoStringSet_Result struct {
	// Value returned by echoStringSet after a successful execution.
	Success map[string]struct{} `json:"success,omitempty"`
}

// ToWire translates a SecondService_EchoStringSet_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 *SecondService_EchoStringSet_Result) ToWire() (wire.Value, error) {
	var (
		fields [1]wire.Field
		i      int = 0
		w      wire.Value
		err    error
	)

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

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

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

// FromWire deserializes a SecondService_EchoStringSet_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 SecondService_EchoStringSet_Result struct
// from the provided intermediate representation.
//
//   x, err := binaryProtocol.Decode(reader, wire.TStruct)
//   if err != nil {
//     return nil, err
//   }
//
//   var v SecondService_EchoStringSet_Result
//   if err := v.FromWire(x); err != nil {
//     return nil, err
//   }
//   return &v, nil
func (v *SecondService_EchoStringSet_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.TSet {
				v.Success, err = _Set_String_mapType_Read(field.Value.GetSet())
				if err != nil {
					return err
				}

			}
		}
	}

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

	return nil
}

// String returns a readable string representation of a SecondService_EchoStringSet_Result
// struct.
func (v *SecondService_EchoStringSet_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("SecondService_EchoStringSet_Result{%v}", strings.Join(fields[:i], ", "))
}

// Equals returns true if all the fields of this SecondService_EchoStringSet_Result match the
// provided SecondService_EchoStringSet_Result.
//
// This function performs a deep comparison.
func (v *SecondService_EchoStringSet_Result) Equals(rhs *SecondService_EchoStringSet_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 && _Set_String_mapType_Equals(v.Success, rhs.Success))) {
		return false
	}

	return true
}

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

// GetSuccess returns the value of Success if it is set or its
// zero value if it is unset.
func (v *SecondService_EchoStringSet_Result) GetSuccess() (o map[string]struct{}) {
	if v != nil && v.Success != nil {
		return v.Success
	}

	return
}

// IsSetSuccess returns true if Success is not nil.
func (v *SecondService_EchoStringSet_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 "echoStringSet" for this struct.
func (v *SecondService_EchoStringSet_Result) MethodName() string {
	return "echoStringSet"
}

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

// SecondService_EchoStructList_Args represents the arguments for the SecondService.echoStructList function.
//
// The arguments for echoStructList are sent and received over the wire as this struct.
type SecondService_EchoStructList_Args struct {
	Arg []*base.BazResponse `json:"arg,required"`
}

type _List_BazResponse_ValueList []*base.BazResponse

func (v _List_BazResponse_ValueList) ForEach(f func(wire.Value) error) error {
	for i, x := range v {
		if x == nil {
			return fmt.Errorf("invalid [%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_BazResponse_ValueList) Size() int {
	return len(v)
}

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

func (_List_BazResponse_ValueList) Close() {}

// ToWire translates a SecondService_EchoStructList_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 *SecondService_EchoStructList_Args) ToWire() (wire.Value, error) {
	var (
		fields [1]wire.Field
		i      int = 0
		w      wire.Value
		err    error
	)

	w, err = wire.NewValueList(_List_BazResponse_ValueList(v.Arg)), 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 _List_BazResponse_Read(l wire.ValueList) ([]*base.BazResponse, error) {
	if l.ValueType() != wire.TStruct {
		return nil, nil
	}

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

// FromWire deserializes a SecondService_EchoStructList_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 SecondService_EchoStructList_Args struct
// from the provided intermediate representation.
//
//   x, err := binaryProtocol.Decode(reader, wire.TStruct)
//   if err != nil {
//     return nil, err
//   }
//
//   var v SecondService_EchoStructList_Args
//   if err := v.FromWire(x); err != nil {
//     return nil, err
//   }
//   return &v, nil
func (v *SecondService_EchoStructList_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.TList {
				v.Arg, err = _List_BazResponse_Read(field.Value.GetList())
				if err != nil {
					return err
				}
				argIsSet = true
			}
		}
	}

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

	return nil
}

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

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

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

func _List_BazResponse_Equals(lhs, rhs []*base.BazResponse) 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 SecondService_EchoStructList_Args match the
// provided SecondService_EchoStructList_Args.
//
// This function performs a deep comparison.
func (v *SecondService_EchoStructList_Args) Equals(rhs *SecondService_EchoStructList_Args) bool {
	if v == nil {
		return rhs == nil
	} else if rhs == nil {
		return false
	}
	if !_List_BazResponse_Equals(v.Arg, rhs.Arg) {
		return false
	}

	return true
}

type _List_BazResponse_Zapper []*base.BazResponse

// MarshalLogArray implements zapcore.ArrayMarshaler, enabling
// fast logging of _List_BazResponse_Zapper.
func (l _List_BazResponse_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 SecondService_EchoStructList_Args.
func (v *SecondService_EchoStructList_Args) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
	if v == nil {
		return nil
	}
	err = multierr.Append(err, enc.AddArray("arg", (_List_BazResponse_Zapper)(v.Arg)))
	return err
}

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

// IsSetArg returns true if Arg is not nil.
func (v *SecondService_EchoStructList_Args) IsSetArg() bool {
	return v != nil && v.Arg != 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 "echoStructList" for this struct.
func (v *SecondService_EchoStructList_Args) MethodName() string {
	return "echoStructList"
}

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

// SecondService_EchoStructList_Helper provides functions that aid in handling the
// parameters and return values of the SecondService.echoStructList
// function.
var SecondService_EchoStructList_Helper = struct {
	// Args accepts the parameters of echoStructList in-order and returns
	// the arguments struct for the function.
	Args func(
		arg []*base.BazResponse,
	) *SecondService_EchoStructList_Args

	// IsException returns true if the given error can be thrown
	// by echoStructList.
	//
	// An error can be thrown by echoStructList 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 echoStructList
	// given its return value and error.
	//
	// This allows mapping values and errors returned by
	// echoStructList into a serializable result struct.
	// WrapResponse returns a non-nil error if the provided
	// error cannot be thrown by echoStructList
	//
	//   value, err := echoStructList(args)
	//   result, err := SecondService_EchoStructList_Helper.WrapResponse(value, err)
	//   if err != nil {
	//     return fmt.Errorf("unexpected error from echoStructList: %v", err)
	//   }
	//   serialize(result)
	WrapResponse func([]*base.BazResponse, error) (*SecondService_EchoStructList_Result, error)

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

func init() {
	SecondService_EchoStructList_Helper.Args = func(
		arg []*base.BazResponse,
	) *SecondService_EchoStructList_Args {
		return &SecondService_EchoStructList_Args{
			Arg: arg,
		}
	}

	SecondService_EchoStructList_Helper.IsException = func(err error) bool {
		switch err.(type) {
		default:
			return false
		}
	}

	SecondService_EchoStructList_Helper.WrapResponse = func(success []*base.BazResponse, err error) (*SecondService_EchoStructList_Result, error) {
		if err == nil {
			return &SecondService_EchoStructList_Result{Success: success}, nil
		}

		return nil, err
	}
	SecondService_EchoStructList_Helper.UnwrapResponse = func(result *SecondService_EchoStructList_Result) (success []*base.BazResponse, err error) {

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

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

}

// SecondService_EchoStructList_Result represents the result of a SecondService.echoStructList function call.
//
// The result of a echoStructList execution is sent and received over the wire as this struct.
//
// Success is set only if the function did not throw an exception.
type SecondService_EchoStructList_Result struct {
	// Value returned by echoStructList after a successful execution.
	Success []*base.BazResponse `json:"success,omitempty"`
}

// ToWire translates a SecondService_EchoStructList_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 *SecondService_EchoStructList_Result) ToWire() (wire.Value, error) {
	var (
		fields [1]wire.Field
		i      int = 0
		w      wire.Value
		err    error
	)

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

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

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

// FromWire deserializes a SecondService_EchoStructList_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 SecondService_EchoStructList_Result struct
// from the provided intermediate representation.
//
//   x, err := binaryProtocol.Decode(reader, wire.TStruct)
//   if err != nil {
//     return nil, err
//   }
//
//   var v SecondService_EchoStructList_Result
//   if err := v.FromWire(x); err != nil {
//     return nil, err
//   }
//   return &v, nil
func (v *SecondService_EchoStructList_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.TList {
				v.Success, err = _List_BazResponse_Read(field.Value.GetList())
				if err != nil {
					return err
				}

			}
		}
	}

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

	return nil
}

// String returns a readable string representation of a SecondService_EchoStructList_Result
// struct.
func (v *SecondService_EchoStructList_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("SecondService_EchoStructList_Result{%v}", strings.Join(fields[:i], ", "))
}

// Equals returns true if all the fields of this SecondService_EchoStructList_Result match the
// provided SecondService_EchoStructList_Result.
//
// This function performs a deep comparison.
func (v *SecondService_EchoStructList_Result) Equals(rhs *SecondService_EchoStructList_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 && _List_BazResponse_Equals(v.Success, rhs.Success))) {
		return false
	}

	return true
}

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

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

	return
}

// IsSetSuccess returns true if Success is not nil.
func (v *SecondService_EchoStructList_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 "echoStructList" for this struct.
func (v *SecondService_EchoStructList_Result) MethodName() string {
	return "echoStructList"
}

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

// SecondService_EchoStructMap_Args represents the arguments for the SecondService.echoStructMap function.
//
// The arguments for echoStructMap are sent and received over the wire as this struct.
type SecondService_EchoStructMap_Args struct {
	Arg []struct {
		Key   *base.BazResponse
		Value string
	} `json:"arg,required"`
}

type _Map_BazResponse_String_MapItemList []struct {
	Key   *base.BazResponse
	Value string
}

func (m _Map_BazResponse_String_MapItemList) ForEach(f func(wire.MapItem) error) error {
	for _, i := range m {
		k := i.Key
		v := i.Value
		if k == nil {
			return fmt.Errorf("invalid map key: value is nil")
		}
		kw, err := k.ToWire()
		if err != nil {
			return err
		}

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

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

func (_Map_BazResponse_String_MapItemList) KeyType() wire.Type {
	return wire.TStruct
}

func (_Map_BazResponse_String_MapItemList) ValueType() wire.Type {
	return wire.TBinary
}

func (_Map_BazResponse_String_MapItemList) Close() {}

// ToWire translates a SecondService_EchoStructMap_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 *SecondService_EchoStructMap_Args) ToWire() (wire.Value, error) {
	var (
		fields [1]wire.Field
		i      int = 0
		w      wire.Value
		err    error
	)

	if v.Arg == nil {
		return w, errors.New("field Arg of SecondService_EchoStructMap_Args is required")
	}
	w, err = wire.NewValueMap(_Map_BazResponse_String_MapItemList(v.Arg)), 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 _Map_BazResponse_String_Read(m wire.MapItemList) ([]struct {
	Key   *base.BazResponse
	Value string
}, error) {
	if m.KeyType() != wire.TStruct {
		return nil, nil
	}

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

	o := make([]struct {
		Key   *base.BazResponse
		Value string
	}, 0, m.Size())
	err := m.ForEach(func(x wire.MapItem) error {
		k, err := _BazResponse_Read(x.Key)
		if err != nil {
			return err
		}

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

		o = append(o, struct {
			Key   *base.BazResponse
			Value string
		}{k, v})
		return nil
	})
	m.Close()
	return o, err
}

// FromWire deserializes a SecondService_EchoStructMap_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 SecondService_EchoStructMap_Args struct
// from the provided intermediate representation.
//
//   x, err := binaryProtocol.Decode(reader, wire.TStruct)
//   if err != nil {
//     return nil, err
//   }
//
//   var v SecondService_EchoStructMap_Args
//   if err := v.FromWire(x); err != nil {
//     return nil, err
//   }
//   return &v, nil
func (v *SecondService_EchoStructMap_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.TMap {
				v.Arg, err = _Map_BazResponse_String_Read(field.Value.GetMap())
				if err != nil {
					return err
				}
				argIsSet = true
			}
		}
	}

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

	return nil
}

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

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

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

func _Map_BazResponse_String_Equals(lhs, rhs []struct {
	Key   *base.BazResponse
	Value string
}) bool {
	if len(lhs) != len(rhs) {
		return false
	}

	for _, i := range lhs {
		lk := i.Key
		lv := i.Value
		ok := false
		for _, j := range rhs {
			rk := j.Key
			rv := j.Value
			if !lk.Equals(rk) {
				continue
			}

			if !(lv == rv) {
				return false
			}
			ok = true
			break
		}

		if !ok {
			return false
		}
	}
	return true
}

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

	return true
}

type _Map_BazResponse_String_Item_Zapper struct {
	Key   *base.BazResponse
	Value string
}

// MarshalLogArray implements zapcore.ArrayMarshaler, enabling
// fast logging of _Map_BazResponse_String_Item_Zapper.
func (v _Map_BazResponse_String_Item_Zapper) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
	err = multierr.Append(err, enc.AddObject("key", v.Key))
	enc.AddString("value", v.Value)
	return err
}

type _Map_BazResponse_String_Zapper []struct {
	Key   *base.BazResponse
	Value string
}

// MarshalLogArray implements zapcore.ArrayMarshaler, enabling
// fast logging of _Map_BazResponse_String_Zapper.
func (m _Map_BazResponse_String_Zapper) MarshalLogArray(enc zapcore.ArrayEncoder) (err error) {
	for _, i := range m {
		k := i.Key
		v := i.Value
		err = multierr.Append(err, enc.AppendObject(_Map_BazResponse_String_Item_Zapper{Key: k, Value: v}))
	}
	return err
}

// MarshalLogObject implements zapcore.ObjectMarshaler, enabling
// fast logging of SecondService_EchoStructMap_Args.
func (v *SecondService_EchoStructMap_Args) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
	if v == nil {
		return nil
	}
	err = multierr.Append(err, enc.AddArray("arg", (_Map_BazResponse_String_Zapper)(v.Arg)))
	return err
}

// GetArg returns the value of Arg if it is set or its
// zero value if it is unset.
func (v *SecondService_EchoStructMap_Args) GetArg() (o []struct {
	Key   *base.BazResponse
	Value string
}) {
	if v != nil {
		o = v.Arg
	}
	return
}

// IsSetArg returns true if Arg is not nil.
func (v *SecondService_EchoStructMap_Args) IsSetArg() bool {
	return v != nil && v.Arg != 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 "echoStructMap" for this struct.
func (v *SecondService_EchoStructMap_Args) MethodName() string {
	return "echoStructMap"
}

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

// SecondService_EchoStructMap_Helper provides functions that aid in handling the
// parameters and return values of the SecondService.echoStructMap
// function.
var SecondService_EchoStructMap_Helper = struct {
	// Args accepts the parameters of echoStructMap in-order and returns
	// the arguments struct for the function.
	Args func(
		arg []struct {
			Key   *base.BazResponse
			Value string
		},
	) *SecondService_EchoStructMap_Args

	// IsException returns true if the given error can be thrown
	// by echoStructMap.
	//
	// An error can be thrown by echoStructMap 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 echoStructMap
	// given its return value and error.
	//
	// This allows mapping values and errors returned by
	// echoStructMap into a serializable result struct.
	// WrapResponse returns a non-nil error if the provided
	// error cannot be thrown by echoStructMap
	//
	//   value, err := echoStructMap(args)
	//   result, err := SecondService_EchoStructMap_Helper.WrapResponse(value, err)
	//   if err != nil {
	//     return fmt.Errorf("unexpected error from echoStructMap: %v", err)
	//   }
	//   serialize(result)
	WrapResponse func([]struct {
		Key   *base.BazResponse
		Value string
	}, error) (*SecondService_EchoStructMap_Result, error)

	// UnwrapResponse takes the result struct for echoStructMap
	// and returns the value or error returned by it.
	//
	// The error is non-nil only if echoStructMap threw an
	// exception.
	//
	//   result := deserialize(bytes)
	//   value, err := SecondService_EchoStructMap_Helper.UnwrapResponse(result)
	UnwrapResponse func(*SecondService_EchoStructMap_Result) ([]struct {
		Key   *base.BazResponse
		Value string
	}, error)
}{}

func init() {
	SecondService_EchoStructMap_Helper.Args = func(
		arg []struct {
			Key   *base.BazResponse
			Value string
		},
	) *SecondService_EchoStructMap_Args {
		return &SecondService_EchoStructMap_Args{
			Arg: arg,
		}
	}

	SecondService_EchoStructMap_Helper.IsException = func(err error) bool {
		switch err.(type) {
		default:
			return false
		}
	}

	SecondService_EchoStructMap_Helper.WrapResponse = func(success []struct {
		Key   *base.BazResponse
		Value string
	}, err error) (*SecondService_EchoStructMap_Result, error) {
		if err == nil {
			return &SecondService_EchoStructMap_Result{Success: success}, nil
		}

		return nil, err
	}
	SecondService_EchoStructMap_Helper.UnwrapResponse = func(result *SecondService_EchoStructMap_Result) (success []struct {
		Key   *base.BazResponse
		Value string
	}, err error) {
		if result.Success != nil {
			success = result.Success
			return
		}
		err = errors.New("expected a non-void result")
		return
	}

}

// SecondService_EchoStructMap_Result represents the result of a SecondService.echoStructMap function call.
//
// The result of a echoStructMap execution is sent and received over the wire as this struct.
//
// Success is set only if the function did not throw an exception.
type SecondService_EchoStructMap_Result struct {
	// Value returned by echoStructMap after a successful execution.
	Success []struct {
		Key   *base.BazResponse
		Value string
	} `json:"success,omitempty"`
}

// ToWire translates a SecondService_EchoStructMap_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 *SecondService_EchoStructMap_Result) ToWire() (wire.Value, error) {
	var (
		fields [1]wire.Field
		i      int = 0
		w      wire.Value
		err    error
	)

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

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

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

// FromWire deserializes a SecondService_EchoStructMap_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 SecondService_EchoStructMap_Result struct
// from the provided intermediate representation.
//
//   x, err := binaryProtocol.Decode(reader, wire.TStruct)
//   if err != nil {
//     return nil, err
//   }
//
//   var v SecondService_EchoStructMap_Result
//   if err := v.FromWire(x); err != nil {
//     return nil, err
//   }
//   return &v, nil
func (v *SecondService_EchoStructMap_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.TMap {
				v.Success, err = _Map_BazResponse_String_Read(field.Value.GetMap())
				if err != nil {
					return err
				}

			}
		}
	}

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

	return nil
}

// String returns a readable string representation of a SecondService_EchoStructMap_Result
// struct.
func (v *SecondService_EchoStructMap_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("SecondService_EchoStructMap_Result{%v}", strings.Join(fields[:i], ", "))
}

// Equals returns true if all the fields of this SecondService_EchoStructMap_Result match the
// provided SecondService_EchoStructMap_Result.
//
// This function performs a deep comparison.
func (v *SecondService_EchoStructMap_Result) Equals(rhs *SecondService_EchoStructMap_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 && _Map_BazResponse_String_Equals(v.Success, rhs.Success))) {
		return false
	}

	return true
}

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

// GetSuccess returns the value of Success if it is set or its
// zero value if it is unset.
func (v *SecondService_EchoStructMap_Result) GetSuccess() (o []struct {
	Key   *base.BazResponse
	Value string
}) {
	if v != nil && v.Success != nil {
		return v.Success
	}

	return
}

// IsSetSuccess returns true if Success is not nil.
func (v *SecondService_EchoStructMap_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 "echoStructMap" for this struct.
func (v *SecondService_EchoStructMap_Result) MethodName() string {
	return "echoStructMap"
}

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

// SecondService_EchoStructSet_Args represents the arguments for the SecondService.echoStructSet function.
//
// The arguments for echoStructSet are sent and received over the wire as this struct.
type SecondService_EchoStructSet_Args struct {
	Arg []*base.BazResponse `json:"arg,required"`
}

type _Set_BazResponse_sliceType_ValueList []*base.BazResponse

func (v _Set_BazResponse_sliceType_ValueList) ForEach(f func(wire.Value) error) error {
	for _, x := range v {
		if x == nil {
			return fmt.Errorf("invalid set item: value is nil")
		}
		w, err := x.ToWire()
		if err != nil {
			return err
		}

		if err := f(w); err != nil {
			return err
		}
	}
	return nil
}

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

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

func (_Set_BazResponse_sliceType_ValueList) Close() {}

// ToWire translates a SecondService_EchoStructSet_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 *SecondService_EchoStructSet_Args) ToWire() (wire.Value, error) {
	var (
		fields [1]wire.Field
		i      int = 0
		w      wire.Value
		err    error
	)

	if v.Arg == nil {
		return w, errors.New("field Arg of SecondService_EchoStructSet_Args is required")
	}
	w, err = wire.NewValueSet(_Set_BazResponse_sliceType_ValueList(v.Arg)), 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 _Set_BazResponse_sliceType_Read(s wire.ValueList) ([]*base.BazResponse, error) {
	if s.ValueType() != wire.TStruct {
		return nil, nil
	}

	o := make([]*base.BazResponse, 0, s.Size())
	err := s.ForEach(func(x wire.Value) error {
		i, err := _BazResponse_Read(x)
		if err != nil {
			return err
		}

		o = append(o, i)
		return nil
	})
	s.Close()
	return o, err
}

// FromWire deserializes a SecondService_EchoStructSet_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 SecondService_EchoStructSet_Args struct
// from the provided intermediate representation.
//
//   x, err := binaryProtocol.Decode(reader, wire.TStruct)
//   if err != nil {
//     return nil, err
//   }
//
//   var v SecondService_EchoStructSet_Args
//   if err := v.FromWire(x); err != nil {
//     return nil, err
//   }
//   return &v, nil
func (v *SecondService_EchoStructSet_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.TSet {
				v.Arg, err = _Set_BazResponse_sliceType_Read(field.Value.GetSet())
				if err != nil {
					return err
				}
				argIsSet = true
			}
		}
	}

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

	return nil
}

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

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

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

func _Set_BazResponse_sliceType_Equals(lhs, rhs []*base.BazResponse) bool {
	if len(lhs) != len(rhs) {
		return false
	}

	for _, x := range lhs {
		ok := false
		for _, y := range rhs {
			if x.Equals(y) {
				ok = true
				break
			}
		}
		if !ok {
			return false
		}
	}

	return true
}

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

	return true
}

type _Set_BazResponse_sliceType_Zapper []*base.BazResponse

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

// MarshalLogObject implements zapcore.ObjectMarshaler, enabling
// fast logging of SecondService_EchoStructSet_Args.
func (v *SecondService_EchoStructSet_Args) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
	if v == nil {
		return nil
	}
	err = multierr.Append(err, enc.AddArray("arg", (_Set_BazResponse_sliceType_Zapper)(v.Arg)))
	return err
}

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

// IsSetArg returns true if Arg is not nil.
func (v *SecondService_EchoStructSet_Args) IsSetArg() bool {
	return v != nil && v.Arg != 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 "echoStructSet" for this struct.
func (v *SecondService_EchoStructSet_Args) MethodName() string {
	return "echoStructSet"
}

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

// SecondService_EchoStructSet_Helper provides functions that aid in handling the
// parameters and return values of the SecondService.echoStructSet
// function.
var SecondService_EchoStructSet_Helper = struct {
	// Args accepts the parameters of echoStructSet in-order and returns
	// the arguments struct for the function.
	Args func(
		arg []*base.BazResponse,
	) *SecondService_EchoStructSet_Args

	// IsException returns true if the given error can be thrown
	// by echoStructSet.
	//
	// An error can be thrown by echoStructSet 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 echoStructSet
	// given its return value and error.
	//
	// This allows mapping values and errors returned by
	// echoStructSet into a serializable result struct.
	// WrapResponse returns a non-nil error if the provided
	// error cannot be thrown by echoStructSet
	//
	//   value, err := echoStructSet(args)
	//   result, err := SecondService_EchoStructSet_Helper.WrapResponse(value, err)
	//   if err != nil {
	//     return fmt.Errorf("unexpected error from echoStructSet: %v", err)
	//   }
	//   serialize(result)
	WrapResponse func([]*base.BazResponse, error) (*SecondService_EchoStructSet_Result, error)

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

func init() {
	SecondService_EchoStructSet_Helper.Args = func(
		arg []*base.BazResponse,
	) *SecondService_EchoStructSet_Args {
		return &SecondService_EchoStructSet_Args{
			Arg: arg,
		}
	}

	SecondService_EchoStructSet_Helper.IsException = func(err error) bool {
		switch err.(type) {
		default:
			return false
		}
	}

	SecondService_EchoStructSet_Helper.WrapResponse = func(success []*base.BazResponse, err error) (*SecondService_EchoStructSet_Result, error) {
		if err == nil {
			return &SecondService_EchoStructSet_Result{Success: success}, nil
		}

		return nil, err
	}
	SecondService_EchoStructSet_Helper.UnwrapResponse = func(result *SecondService_EchoStructSet_Result) (success []*base.BazResponse, err error) {

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

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

}

// SecondService_EchoStructSet_Result represents the result of a SecondService.echoStructSet function call.
//
// The result of a echoStructSet execution is sent and received over the wire as this struct.
//
// Success is set only if the function did not throw an exception.
type SecondService_EchoStructSet_Result struct {
	// Value returned by echoStructSet after a successful execution.
	Success []*base.BazResponse `json:"success,omitempty"`
}

// ToWire translates a SecondService_EchoStructSet_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 *SecondService_EchoStructSet_Result) ToWire() (wire.Value, error) {
	var (
		fields [1]wire.Field
		i      int = 0
		w      wire.Value
		err    error
	)

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

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

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

// FromWire deserializes a SecondService_EchoStructSet_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 SecondService_EchoStructSet_Result struct
// from the provided intermediate representation.
//
//   x, err := binaryProtocol.Decode(reader, wire.TStruct)
//   if err != nil {
//     return nil, err
//   }
//
//   var v SecondService_EchoStructSet_Result
//   if err := v.FromWire(x); err != nil {
//     return nil, err
//   }
//   return &v, nil
func (v *SecondService_EchoStructSet_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.TSet {
				v.Success, err = _Set_BazResponse_sliceType_Read(field.Value.GetSet())
				if err != nil {
					return err
				}

			}
		}
	}

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

	return nil
}

// String returns a readable string representation of a SecondService_EchoStructSet_Result
// struct.
func (v *SecondService_EchoStructSet_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("SecondService_EchoStructSet_Result{%v}", strings.Join(fields[:i], ", "))
}

// Equals returns true if all the fields of this SecondService_EchoStructSet_Result match the
// provided SecondService_EchoStructSet_Result.
//
// This function performs a deep comparison.
func (v *SecondService_EchoStructSet_Result) Equals(rhs *SecondService_EchoStructSet_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 && _Set_BazResponse_sliceType_Equals(v.Success, rhs.Success))) {
		return false
	}

	return true
}

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

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

	return
}

// IsSetSuccess returns true if Success is not nil.
func (v *SecondService_EchoStructSet_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 "echoStructSet" for this struct.
func (v *SecondService_EchoStructSet_Result) MethodName() string {
	return "echoStructSet"
}

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

// SecondService_EchoTypedef_Args represents the arguments for the SecondService.echoTypedef function.
//
// The arguments for echoTypedef are sent and received over the wire as this struct.
type SecondService_EchoTypedef_Args struct {
	Arg base.UUID `json:"arg,required"`
}

// ToWire translates a SecondService_EchoTypedef_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 *SecondService_EchoTypedef_Args) ToWire() (wire.Value, error) {
	var (
		fields [1]wire.Field
		i      int = 0
		w      wire.Value
		err    error
	)

	w, err = v.Arg.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_1_Read(w wire.Value) (base.UUID, error) {
	var x base.UUID
	err := x.FromWire(w)
	return x, err
}

// FromWire deserializes a SecondService_EchoTypedef_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 SecondService_EchoTypedef_Args struct
// from the provided intermediate representation.
//
//   x, err := binaryProtocol.Decode(reader, wire.TStruct)
//   if err != nil {
//     return nil, err
//   }
//
//   var v SecondService_EchoTypedef_Args
//   if err := v.FromWire(x); err != nil {
//     return nil, err
//   }
//   return &v, nil
func (v *SecondService_EchoTypedef_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.TBinary {
				v.Arg, err = _UUID_1_Read(field.Value)
				if err != nil {
					return err
				}
				argIsSet = true
			}
		}
	}

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

	return nil
}

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

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

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

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

	return true
}

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

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

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

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

// SecondService_EchoTypedef_Helper provides functions that aid in handling the
// parameters and return values of the SecondService.echoTypedef
// function.
var SecondService_EchoTypedef_Helper = struct {
	// Args accepts the parameters of echoTypedef in-order and returns
	// the arguments struct for the function.
	Args func(
		arg base.UUID,
	) *SecondService_EchoTypedef_Args

	// IsException returns true if the given error can be thrown
	// by echoTypedef.
	//
	// An error can be thrown by echoTypedef 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 echoTypedef
	// given its return value and error.
	//
	// This allows mapping values and errors returned by
	// echoTypedef into a serializable result struct.
	// WrapResponse returns a non-nil error if the provided
	// error cannot be thrown by echoTypedef
	//
	//   value, err := echoTypedef(args)
	//   result, err := SecondService_EchoTypedef_Helper.WrapResponse(value, err)
	//   if err != nil {
	//     return fmt.Errorf("unexpected error from echoTypedef: %v", err)
	//   }
	//   serialize(result)
	WrapResponse func(base.UUID, error) (*SecondService_EchoTypedef_Result, error)

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

func init() {
	SecondService_EchoTypedef_Helper.Args = func(
		arg base.UUID,
	) *SecondService_EchoTypedef_Args {
		return &SecondService_EchoTypedef_Args{
			Arg: arg,
		}
	}

	SecondService_EchoTypedef_Helper.IsException = func(err error) bool {
		switch err.(type) {
		default:
			return false
		}
	}

	SecondService_EchoTypedef_Helper.WrapResponse = func(success base.UUID, err error) (*SecondService_EchoTypedef_Result, error) {
		if err == nil {
			return &SecondService_EchoTypedef_Result{Success: &success}, nil
		}

		return nil, err
	}
	SecondService_EchoTypedef_Helper.UnwrapResponse = func(result *SecondService_EchoTypedef_Result) (success base.UUID, err error) {

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

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

}

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

// ToWire translates a SecondService_EchoTypedef_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 *SecondService_EchoTypedef_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("SecondService_EchoTypedef_Result should have exactly one field: got %v fields", i)
	}

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

// FromWire deserializes a SecondService_EchoTypedef_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 SecondService_EchoTypedef_Result struct
// from the provided intermediate representation.
//
//   x, err := binaryProtocol.Decode(reader, wire.TStruct)
//   if err != nil {
//     return nil, err
//   }
//
//   var v SecondService_EchoTypedef_Result
//   if err := v.FromWire(x); err != nil {
//     return nil, err
//   }
//   return &v, nil
func (v *SecondService_EchoTypedef_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.TBinary {
				var x base.UUID
				x, err = _UUID_1_Read(field.Value)
				v.Success = &x
				if err != nil {
					return err
				}

			}
		}
	}

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

	return nil
}

// String returns a readable string representation of a SecondService_EchoTypedef_Result
// struct.
func (v *SecondService_EchoTypedef_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("SecondService_EchoTypedef_Result{%v}", strings.Join(fields[:i], ", "))
}

func _UUID_1_EqualsPtr(lhs, rhs *base.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 SecondService_EchoTypedef_Result match the
// provided SecondService_EchoTypedef_Result.
//
// This function performs a deep comparison.
func (v *SecondService_EchoTypedef_Result) Equals(rhs *SecondService_EchoTypedef_Result) bool {
	if v == nil {
		return rhs == nil
	} else if rhs == nil {
		return false
	}
	if !_UUID_1_EqualsPtr(v.Success, rhs.Success) {
		return false
	}

	return true
}

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

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

	return
}

// IsSetSuccess returns true if Success is not nil.
func (v *SecondService_EchoTypedef_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 "echoTypedef" for this struct.
func (v *SecondService_EchoTypedef_Result) MethodName() string {
	return "echoTypedef"
}

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

// 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
}

// 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], ", "))
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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(*base.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) (*base.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 *base.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 *base.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      *base.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 _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
}

// 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 *base.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
}

// 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
}

// 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
}

// 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
}

// 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
}

// 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(*base.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) (*base.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 *base.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 *base.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 *base.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
}

// 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 *base.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
}

// 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 *base.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 *base.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 *base.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) (*base.ServerErr, error) {
	var v base.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
}

// 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 *base.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
}

// 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
}

// 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 *base.TransStruct `json:"arg1,required"`
	Arg2 *base.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) (*base.TransStruct, error) {
	var v base.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
}

// 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 *base.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 *base.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 *base.TransStruct,
		arg2 *base.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(*base.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) (*base.TransStruct, error)
}{}

func init() {
	SimpleService_Trans_Helper.Args = func(
		arg1 *base.TransStruct,
		arg2 *base.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 *base.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 *base.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      *base.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
}

// 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 *base.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 *base.TransHeaders `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 _TransHeaders_Read(w wire.Value) (*base.TransHeaders, error) {
	var v base.TransHeaders
	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 = _TransHeaders_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
}

// 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 *base.TransHeaders) {
	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 *base.TransHeaders,
	) *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(*base.TransHeaders, 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) (*base.TransHeaders, error)
}{}

func init() {
	SimpleService_TransHeaders_Helper.Args = func(
		req *base.TransHeaders,
	) *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 *base.TransHeaders, 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 *base.TransHeaders, 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      *base.TransHeaders `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 = _TransHeaders_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
}

// 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 *base.TransHeaders) {
	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 {
	Req *base.NestedStruct `json:"req,required"`
	S2  *string            `json:"s2,omitempty"`
	I3  int32              `json:"i3,required"`
	B4  *bool              `json:"b4,omitempty"`
}

// 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 [4]wire.Field
		i      int = 0
		w      wire.Value
		err    error
	)

	if v.Req == nil {
		return w, errors.New("field Req of SimpleService_TransHeadersNoReq_Args is required")
	}
	w, err = v.Req.ToWire()
	if err != nil {
		return w, err
	}
	fields[i] = wire.Field{ID: 1, Value: w}
	i++
	if v.S2 != nil {
		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++
	if v.B4 != nil {
		w, err = wire.NewValueBool(*(v.B4)), error(nil)
		if err != nil {
			return w, err
		}
		fields[i] = wire.Field{ID: 4, Value: w}
		i++
	}

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

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

// 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 {
	var err error

	reqIsSet := false

	i3IsSet := false

	for _, field := range w.GetStruct().Fields {
		switch field.ID {
		case 1:
			if field.Value.Type() == wire.TStruct {
				v.Req, err = _NestedStruct_Read(field.Value)
				if err != nil {
					return err
				}
				reqIsSet = true
			}
		case 2:
			if field.Value.Type() == wire.TBinary {
				var x string
				x, err = field.Value.GetString(), error(nil)
				v.S2 = &x
				if err != nil {
					return err
				}

			}
		case 3:
			if field.Value.Type() == wire.TI32 {
				v.I3, err = field.Value.GetI32(), error(nil)
				if err != nil {
					return err
				}
				i3IsSet = true
			}
		case 4:
			if field.Value.Type() == wire.TBool {
				var x bool
				x, err = field.Value.GetBool(), error(nil)
				v.B4 = &x
				if err != nil {
					return err
				}

			}
		}
	}

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

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

	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 [4]string
	i := 0
	fields[i] = fmt.Sprintf("Req: %v", v.Req)
	i++
	if v.S2 != nil {
		fields[i] = fmt.Sprintf("S2: %v", *(v.S2))
		i++
	}
	fields[i] = fmt.Sprintf("I3: %v", v.I3)
	i++
	if v.B4 != nil {
		fields[i] = fmt.Sprintf("B4: %v", *(v.B4))
		i++
	}

	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
	}
	if !v.Req.Equals(rhs.Req) {
		return false
	}
	if !_String_EqualsPtr(v.S2, rhs.S2) {
		return false
	}
	if !(v.I3 == rhs.I3) {
		return false
	}
	if !_Bool_EqualsPtr(v.B4, rhs.B4) {
		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
	}
	err = multierr.Append(err, enc.AddObject("req", v.Req))
	if v.S2 != nil {
		enc.AddString("s2", *v.S2)
	}
	enc.AddInt32("i3", v.I3)
	if v.B4 != nil {
		enc.AddBool("b4", *v.B4)
	}
	return err
}

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

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

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

	return
}

// IsSetS2 returns true if S2 is not nil.
func (v *SimpleService_TransHeadersNoReq_Args) IsSetS2() bool {
	return v != nil && v.S2 != nil
}

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

// GetB4 returns the value of B4 if it is set or its
// zero value if it is unset.
func (v *SimpleService_TransHeadersNoReq_Args) GetB4() (o bool) {
	if v != nil && v.B4 != nil {
		return *v.B4
	}

	return
}

// IsSetB4 returns true if B4 is not nil.
func (v *SimpleService_TransHeadersNoReq_Args) IsSetB4() bool {
	return v != nil && v.B4 != 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 "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(
		req *base.NestedStruct,
		s2 *string,
		i3 int32,
		b4 *bool,
	) *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(*base.TransHeaders, 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) (*base.TransHeaders, error)
}{}

func init() {
	SimpleService_TransHeadersNoReq_Helper.Args = func(
		req *base.NestedStruct,
		s2 *string,
		i3 int32,
		b4 *bool,
	) *SimpleService_TransHeadersNoReq_Args {
		return &SimpleService_TransHeadersNoReq_Args{
			Req: req,
			S2:  s2,
			I3:  i3,
			B4:  b4,
		}
	}

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

	SimpleService_TransHeadersNoReq_Helper.WrapResponse = func(success *base.TransHeaders, 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 *base.TransHeaders, 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 *base.TransHeaders `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 = _TransHeaders_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
}

// 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 *base.TransHeaders) {
	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 *TransHeaderType `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
}

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

// 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 = _TransHeaderType_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
}

// 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 *TransHeaderType) {
	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 *TransHeaderType,
	) *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(*TransHeaderType, 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) (*TransHeaderType, error)
}{}

func init() {
	SimpleService_TransHeadersType_Helper.Args = func(
		req *TransHeaderType,
	) *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 *TransHeaderType, 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 *TransHeaderType, 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      *TransHeaderType `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 = _TransHeaderType_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
}

// 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 *TransHeaderType) {
	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
}

// 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
}

// 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
}