containers.go

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

package containers

import (
	bytes "bytes"
	base64 "encoding/base64"
	errors "errors"
	fmt "fmt"
	multierr "go.uber.org/multierr"
	enum_conflict "go.uber.org/thriftrw/gen/internal/tests/enum_conflict"
	enums "go.uber.org/thriftrw/gen/internal/tests/enums"
	typedefs "go.uber.org/thriftrw/gen/internal/tests/typedefs"
	uuid_conflict "go.uber.org/thriftrw/gen/internal/tests/uuid_conflict"
	thriftreflect "go.uber.org/thriftrw/thriftreflect"
	wire "go.uber.org/thriftrw/wire"
	zapcore "go.uber.org/zap/zapcore"
	strings "strings"
)

type ContainersOfContainers struct {
	ListOfLists   [][]int32             `json:"listOfLists,omitempty"`
	ListOfSets    []map[int32]struct{}  `json:"listOfSets,omitempty"`
	ListOfMaps    []map[int32]int32     `json:"listOfMaps,omitempty"`
	SetOfSets     []map[string]struct{} `json:"setOfSets,omitempty"`
	SetOfLists    [][]string            `json:"setOfLists,omitempty"`
	SetOfMaps     []map[string]string   `json:"setOfMaps,omitempty"`
	MapOfMapToInt []struct {
		Key   map[string]int32
		Value int64
	} `json:"mapOfMapToInt,omitempty"`
	MapOfListToSet []struct {
		Key   []int32
		Value map[int64]struct{}
	} `json:"mapOfListToSet,omitempty"`
	MapOfSetToListOfDouble []struct {
		Key   map[int32]struct{}
		Value []float64
	} `json:"mapOfSetToListOfDouble,omitempty"`
}

type _List_I32_ValueList []int32

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

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

func (_List_I32_ValueList) ValueType() wire.Type {
	return wire.TI32
}

func (_List_I32_ValueList) Close() {}

type _List_List_I32_ValueList [][]int32

func (v _List_List_I32_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 := wire.NewValueList(_List_I32_ValueList(x)), error(nil)
		if err != nil {
			return err
		}
		err = f(w)
		if err != nil {
			return err
		}
	}
	return nil
}

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

func (_List_List_I32_ValueList) ValueType() wire.Type {
	return wire.TList
}

func (_List_List_I32_ValueList) Close() {}

type _Set_I32_mapType_ValueList map[int32]struct{}

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

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

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

func (_Set_I32_mapType_ValueList) ValueType() wire.Type {
	return wire.TI32
}

func (_Set_I32_mapType_ValueList) Close() {}

type _List_Set_I32_mapType_ValueList []map[int32]struct{}

func (v _List_Set_I32_mapType_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 := wire.NewValueSet(_Set_I32_mapType_ValueList(x)), error(nil)
		if err != nil {
			return err
		}
		err = f(w)
		if err != nil {
			return err
		}
	}
	return nil
}

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

func (_List_Set_I32_mapType_ValueList) ValueType() wire.Type {
	return wire.TSet
}

func (_List_Set_I32_mapType_ValueList) Close() {}

type _Map_I32_I32_MapItemList map[int32]int32

func (m _Map_I32_I32_MapItemList) ForEach(f func(wire.MapItem) error) error {
	for k, v := range m {
		kw, err := wire.NewValueI32(k), error(nil)
		if err != nil {
			return err
		}

		vw, err := wire.NewValueI32(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_I32_I32_MapItemList) Size() int {
	return len(m)
}

func (_Map_I32_I32_MapItemList) KeyType() wire.Type {
	return wire.TI32
}

func (_Map_I32_I32_MapItemList) ValueType() wire.Type {
	return wire.TI32
}

func (_Map_I32_I32_MapItemList) Close() {}

type _List_Map_I32_I32_ValueList []map[int32]int32

func (v _List_Map_I32_I32_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 := wire.NewValueMap(_Map_I32_I32_MapItemList(x)), error(nil)
		if err != nil {
			return err
		}
		err = f(w)
		if err != nil {
			return err
		}
	}
	return nil
}

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

func (_List_Map_I32_I32_ValueList) ValueType() wire.Type {
	return wire.TMap
}

func (_List_Map_I32_I32_ValueList) Close() {}

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() {}

type _Set_Set_String_mapType_sliceType_ValueList []map[string]struct{}

func (v _Set_Set_String_mapType_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 := wire.NewValueSet(_Set_String_mapType_ValueList(x)), error(nil)
		if err != nil {
			return err
		}

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

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

func (_Set_Set_String_mapType_sliceType_ValueList) ValueType() wire.Type {
	return wire.TSet
}

func (_Set_Set_String_mapType_sliceType_ValueList) Close() {}

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() {}

type _Set_List_String_sliceType_ValueList [][]string

func (v _Set_List_String_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 := wire.NewValueList(_List_String_ValueList(x)), error(nil)
		if err != nil {
			return err
		}

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

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

func (_Set_List_String_sliceType_ValueList) ValueType() wire.Type {
	return wire.TList
}

func (_Set_List_String_sliceType_ValueList) Close() {}

type _Map_String_String_MapItemList map[string]string

func (m _Map_String_String_MapItemList) ForEach(f func(wire.MapItem) error) error {
	for k, v := range m {
		kw, err := wire.NewValueString(k), error(nil)
		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_String_String_MapItemList) Size() int {
	return len(m)
}

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

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

func (_Map_String_String_MapItemList) Close() {}

type _Set_Map_String_String_sliceType_ValueList []map[string]string

func (v _Set_Map_String_String_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 := wire.NewValueMap(_Map_String_String_MapItemList(x)), error(nil)
		if err != nil {
			return err
		}

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

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

func (_Set_Map_String_String_sliceType_ValueList) ValueType() wire.Type {
	return wire.TMap
}

func (_Set_Map_String_String_sliceType_ValueList) Close() {}

type _Map_String_I32_MapItemList map[string]int32

func (m _Map_String_I32_MapItemList) ForEach(f func(wire.MapItem) error) error {
	for k, v := range m {
		kw, err := wire.NewValueString(k), error(nil)
		if err != nil {
			return err
		}

		vw, err := wire.NewValueI32(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_String_I32_MapItemList) Size() int {
	return len(m)
}

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

func (_Map_String_I32_MapItemList) ValueType() wire.Type {
	return wire.TI32
}

func (_Map_String_I32_MapItemList) Close() {}

type _Map_Map_String_I32_I64_MapItemList []struct {
	Key   map[string]int32
	Value int64
}

func (m _Map_Map_String_I32_I64_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 := wire.NewValueMap(_Map_String_I32_MapItemList(k)), error(nil)
		if err != nil {
			return err
		}

		vw, err := wire.NewValueI64(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_Map_String_I32_I64_MapItemList) Size() int {
	return len(m)
}

func (_Map_Map_String_I32_I64_MapItemList) KeyType() wire.Type {
	return wire.TMap
}

func (_Map_Map_String_I32_I64_MapItemList) ValueType() wire.Type {
	return wire.TI64
}

func (_Map_Map_String_I32_I64_MapItemList) Close() {}

type _Set_I64_mapType_ValueList map[int64]struct{}

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

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

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

func (_Set_I64_mapType_ValueList) ValueType() wire.Type {
	return wire.TI64
}

func (_Set_I64_mapType_ValueList) Close() {}

type _Map_List_I32_Set_I64_mapType_MapItemList []struct {
	Key   []int32
	Value map[int64]struct{}
}

func (m _Map_List_I32_Set_I64_mapType_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")
		}
		if v == nil {
			return fmt.Errorf("invalid [%v]: value is nil", k)
		}
		kw, err := wire.NewValueList(_List_I32_ValueList(k)), error(nil)
		if err != nil {
			return err
		}

		vw, err := wire.NewValueSet(_Set_I64_mapType_ValueList(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_List_I32_Set_I64_mapType_MapItemList) Size() int {
	return len(m)
}

func (_Map_List_I32_Set_I64_mapType_MapItemList) KeyType() wire.Type {
	return wire.TList
}

func (_Map_List_I32_Set_I64_mapType_MapItemList) ValueType() wire.Type {
	return wire.TSet
}

func (_Map_List_I32_Set_I64_mapType_MapItemList) Close() {}

type _List_Double_ValueList []float64

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

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

func (_List_Double_ValueList) ValueType() wire.Type {
	return wire.TDouble
}

func (_List_Double_ValueList) Close() {}

type _Map_Set_I32_mapType_List_Double_MapItemList []struct {
	Key   map[int32]struct{}
	Value []float64
}

func (m _Map_Set_I32_mapType_List_Double_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")
		}
		if v == nil {
			return fmt.Errorf("invalid [%v]: value is nil", k)
		}
		kw, err := wire.NewValueSet(_Set_I32_mapType_ValueList(k)), error(nil)
		if err != nil {
			return err
		}

		vw, err := wire.NewValueList(_List_Double_ValueList(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_Set_I32_mapType_List_Double_MapItemList) Size() int {
	return len(m)
}

func (_Map_Set_I32_mapType_List_Double_MapItemList) KeyType() wire.Type {
	return wire.TSet
}

func (_Map_Set_I32_mapType_List_Double_MapItemList) ValueType() wire.Type {
	return wire.TList
}

func (_Map_Set_I32_mapType_List_Double_MapItemList) Close() {}

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

	if v.ListOfLists != nil {
		w, err = wire.NewValueList(_List_List_I32_ValueList(v.ListOfLists)), error(nil)
		if err != nil {
			return w, err
		}
		fields[i] = wire.Field{ID: 1, Value: w}
		i++
	}
	if v.ListOfSets != nil {
		w, err = wire.NewValueList(_List_Set_I32_mapType_ValueList(v.ListOfSets)), error(nil)
		if err != nil {
			return w, err
		}
		fields[i] = wire.Field{ID: 2, Value: w}
		i++
	}
	if v.ListOfMaps != nil {
		w, err = wire.NewValueList(_List_Map_I32_I32_ValueList(v.ListOfMaps)), error(nil)
		if err != nil {
			return w, err
		}
		fields[i] = wire.Field{ID: 3, Value: w}
		i++
	}
	if v.SetOfSets != nil {
		w, err = wire.NewValueSet(_Set_Set_String_mapType_sliceType_ValueList(v.SetOfSets)), error(nil)
		if err != nil {
			return w, err
		}
		fields[i] = wire.Field{ID: 4, Value: w}
		i++
	}
	if v.SetOfLists != nil {
		w, err = wire.NewValueSet(_Set_List_String_sliceType_ValueList(v.SetOfLists)), error(nil)
		if err != nil {
			return w, err
		}
		fields[i] = wire.Field{ID: 5, Value: w}
		i++
	}
	if v.SetOfMaps != nil {
		w, err = wire.NewValueSet(_Set_Map_String_String_sliceType_ValueList(v.SetOfMaps)), error(nil)
		if err != nil {
			return w, err
		}
		fields[i] = wire.Field{ID: 6, Value: w}
		i++
	}
	if v.MapOfMapToInt != nil {
		w, err = wire.NewValueMap(_Map_Map_String_I32_I64_MapItemList(v.MapOfMapToInt)), error(nil)
		if err != nil {
			return w, err
		}
		fields[i] = wire.Field{ID: 7, Value: w}
		i++
	}
	if v.MapOfListToSet != nil {
		w, err = wire.NewValueMap(_Map_List_I32_Set_I64_mapType_MapItemList(v.MapOfListToSet)), error(nil)
		if err != nil {
			return w, err
		}
		fields[i] = wire.Field{ID: 8, Value: w}
		i++
	}
	if v.MapOfSetToListOfDouble != nil {
		w, err = wire.NewValueMap(_Map_Set_I32_mapType_List_Double_MapItemList(v.MapOfSetToListOfDouble)), error(nil)
		if err != nil {
			return w, err
		}
		fields[i] = wire.Field{ID: 9, Value: w}
		i++
	}

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

func _List_I32_Read(l wire.ValueList) ([]int32, error) {
	if l.ValueType() != wire.TI32 {
		return nil, nil
	}

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

func _List_List_I32_Read(l wire.ValueList) ([][]int32, error) {
	if l.ValueType() != wire.TList {
		return nil, nil
	}

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

func _Set_I32_mapType_Read(s wire.ValueList) (map[int32]struct{}, error) {
	if s.ValueType() != wire.TI32 {
		return nil, nil
	}

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

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

func _List_Set_I32_mapType_Read(l wire.ValueList) ([]map[int32]struct{}, error) {
	if l.ValueType() != wire.TSet {
		return nil, nil
	}

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

func _Map_I32_I32_Read(m wire.MapItemList) (map[int32]int32, error) {
	if m.KeyType() != wire.TI32 {
		return nil, nil
	}

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

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

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

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

func _List_Map_I32_I32_Read(l wire.ValueList) ([]map[int32]int32, error) {
	if l.ValueType() != wire.TMap {
		return nil, nil
	}

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

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
}

func _Set_Set_String_mapType_sliceType_Read(s wire.ValueList) ([]map[string]struct{}, error) {
	if s.ValueType() != wire.TSet {
		return nil, nil
	}

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

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

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
}

func _Set_List_String_sliceType_Read(s wire.ValueList) ([][]string, error) {
	if s.ValueType() != wire.TList {
		return nil, nil
	}

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

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

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

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

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

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

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

func _Set_Map_String_String_sliceType_Read(s wire.ValueList) ([]map[string]string, error) {
	if s.ValueType() != wire.TMap {
		return nil, nil
	}

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

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

func _Map_String_I32_Read(m wire.MapItemList) (map[string]int32, error) {
	if m.KeyType() != wire.TBinary {
		return nil, nil
	}

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

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

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

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

func _Map_Map_String_I32_I64_Read(m wire.MapItemList) ([]struct {
	Key   map[string]int32
	Value int64
}, error) {
	if m.KeyType() != wire.TMap {
		return nil, nil
	}

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

	o := make([]struct {
		Key   map[string]int32
		Value int64
	}, 0, m.Size())
	err := m.ForEach(func(x wire.MapItem) error {
		k, err := _Map_String_I32_Read(x.Key.GetMap())
		if err != nil {
			return err
		}

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

		o = append(o, struct {
			Key   map[string]int32
			Value int64
		}{k, v})
		return nil
	})
	m.Close()
	return o, err
}

func _Set_I64_mapType_Read(s wire.ValueList) (map[int64]struct{}, error) {
	if s.ValueType() != wire.TI64 {
		return nil, nil
	}

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

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

func _Map_List_I32_Set_I64_mapType_Read(m wire.MapItemList) ([]struct {
	Key   []int32
	Value map[int64]struct{}
}, error) {
	if m.KeyType() != wire.TList {
		return nil, nil
	}

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

	o := make([]struct {
		Key   []int32
		Value map[int64]struct{}
	}, 0, m.Size())
	err := m.ForEach(func(x wire.MapItem) error {
		k, err := _List_I32_Read(x.Key.GetList())
		if err != nil {
			return err
		}

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

		o = append(o, struct {
			Key   []int32
			Value map[int64]struct{}
		}{k, v})
		return nil
	})
	m.Close()
	return o, err
}

func _List_Double_Read(l wire.ValueList) ([]float64, error) {
	if l.ValueType() != wire.TDouble {
		return nil, nil
	}

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

func _Map_Set_I32_mapType_List_Double_Read(m wire.MapItemList) ([]struct {
	Key   map[int32]struct{}
	Value []float64
}, error) {
	if m.KeyType() != wire.TSet {
		return nil, nil
	}

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

	o := make([]struct {
		Key   map[int32]struct{}
		Value []float64
	}, 0, m.Size())
	err := m.ForEach(func(x wire.MapItem) error {
		k, err := _Set_I32_mapType_Read(x.Key.GetSet())
		if err != nil {
			return err
		}

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

		o = append(o, struct {
			Key   map[int32]struct{}
			Value []float64
		}{k, v})
		return nil
	})
	m.Close()
	return o, err
}

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

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

			}
		case 2:
			if field.Value.Type() == wire.TList {
				v.ListOfSets, err = _List_Set_I32_mapType_Read(field.Value.GetList())
				if err != nil {
					return err
				}

			}
		case 3:
			if field.Value.Type() == wire.TList {
				v.ListOfMaps, err = _List_Map_I32_I32_Read(field.Value.GetList())
				if err != nil {
					return err
				}

			}
		case 4:
			if field.Value.Type() == wire.TSet {
				v.SetOfSets, err = _Set_Set_String_mapType_sliceType_Read(field.Value.GetSet())
				if err != nil {
					return err
				}

			}
		case 5:
			if field.Value.Type() == wire.TSet {
				v.SetOfLists, err = _Set_List_String_sliceType_Read(field.Value.GetSet())
				if err != nil {
					return err
				}

			}
		case 6:
			if field.Value.Type() == wire.TSet {
				v.SetOfMaps, err = _Set_Map_String_String_sliceType_Read(field.Value.GetSet())
				if err != nil {
					return err
				}

			}
		case 7:
			if field.Value.Type() == wire.TMap {
				v.MapOfMapToInt, err = _Map_Map_String_I32_I64_Read(field.Value.GetMap())
				if err != nil {
					return err
				}

			}
		case 8:
			if field.Value.Type() == wire.TMap {
				v.MapOfListToSet, err = _Map_List_I32_Set_I64_mapType_Read(field.Value.GetMap())
				if err != nil {
					return err
				}

			}
		case 9:
			if field.Value.Type() == wire.TMap {
				v.MapOfSetToListOfDouble, err = _Map_Set_I32_mapType_List_Double_Read(field.Value.GetMap())
				if err != nil {
					return err
				}

			}
		}
	}

	return nil
}

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

	var fields [9]string
	i := 0
	if v.ListOfLists != nil {
		fields[i] = fmt.Sprintf("ListOfLists: %v", v.ListOfLists)
		i++
	}
	if v.ListOfSets != nil {
		fields[i] = fmt.Sprintf("ListOfSets: %v", v.ListOfSets)
		i++
	}
	if v.ListOfMaps != nil {
		fields[i] = fmt.Sprintf("ListOfMaps: %v", v.ListOfMaps)
		i++
	}
	if v.SetOfSets != nil {
		fields[i] = fmt.Sprintf("SetOfSets: %v", v.SetOfSets)
		i++
	}
	if v.SetOfLists != nil {
		fields[i] = fmt.Sprintf("SetOfLists: %v", v.SetOfLists)
		i++
	}
	if v.SetOfMaps != nil {
		fields[i] = fmt.Sprintf("SetOfMaps: %v", v.SetOfMaps)
		i++
	}
	if v.MapOfMapToInt != nil {
		fields[i] = fmt.Sprintf("MapOfMapToInt: %v", v.MapOfMapToInt)
		i++
	}
	if v.MapOfListToSet != nil {
		fields[i] = fmt.Sprintf("MapOfListToSet: %v", v.MapOfListToSet)
		i++
	}
	if v.MapOfSetToListOfDouble != nil {
		fields[i] = fmt.Sprintf("MapOfSetToListOfDouble: %v", v.MapOfSetToListOfDouble)
		i++
	}

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

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

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

	return true
}

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

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

	return true
}

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

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

	return true
}

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

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

	return true
}

func _Map_I32_I32_Equals(lhs, rhs map[int32]int32) bool {
	if len(lhs) != len(rhs) {
		return false
	}

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

func _List_Map_I32_I32_Equals(lhs, rhs []map[int32]int32) bool {
	if len(lhs) != len(rhs) {
		return false
	}

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

	return true
}

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
}

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

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

	return true
}

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
}

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

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

	return true
}

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

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

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

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

	return true
}

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

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

func _Map_Map_String_I32_I64_Equals(lhs, rhs []struct {
	Key   map[string]int32
	Value int64
}) 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 !_Map_String_I32_Equals(lk, rk) {
				continue
			}

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

		if !ok {
			return false
		}
	}
	return true
}

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

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

	return true
}

func _Map_List_I32_Set_I64_mapType_Equals(lhs, rhs []struct {
	Key   []int32
	Value map[int64]struct{}
}) 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 !_List_I32_Equals(lk, rk) {
				continue
			}

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

		if !ok {
			return false
		}
	}
	return true
}

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

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

	return true
}

func _Map_Set_I32_mapType_List_Double_Equals(lhs, rhs []struct {
	Key   map[int32]struct{}
	Value []float64
}) 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 !_Set_I32_mapType_Equals(lk, rk) {
				continue
			}

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

		if !ok {
			return false
		}
	}
	return true
}

// Equals returns true if all the fields of this ContainersOfContainers match the
// provided ContainersOfContainers.
//
// This function performs a deep comparison.
func (v *ContainersOfContainers) Equals(rhs *ContainersOfContainers) bool {
	if v == nil {
		return rhs == nil
	} else if rhs == nil {
		return false
	}
	if !((v.ListOfLists == nil && rhs.ListOfLists == nil) || (v.ListOfLists != nil && rhs.ListOfLists != nil && _List_List_I32_Equals(v.ListOfLists, rhs.ListOfLists))) {
		return false
	}
	if !((v.ListOfSets == nil && rhs.ListOfSets == nil) || (v.ListOfSets != nil && rhs.ListOfSets != nil && _List_Set_I32_mapType_Equals(v.ListOfSets, rhs.ListOfSets))) {
		return false
	}
	if !((v.ListOfMaps == nil && rhs.ListOfMaps == nil) || (v.ListOfMaps != nil && rhs.ListOfMaps != nil && _List_Map_I32_I32_Equals(v.ListOfMaps, rhs.ListOfMaps))) {
		return false
	}
	if !((v.SetOfSets == nil && rhs.SetOfSets == nil) || (v.SetOfSets != nil && rhs.SetOfSets != nil && _Set_Set_String_mapType_sliceType_Equals(v.SetOfSets, rhs.SetOfSets))) {
		return false
	}
	if !((v.SetOfLists == nil && rhs.SetOfLists == nil) || (v.SetOfLists != nil && rhs.SetOfLists != nil && _Set_List_String_sliceType_Equals(v.SetOfLists, rhs.SetOfLists))) {
		return false
	}
	if !((v.SetOfMaps == nil && rhs.SetOfMaps == nil) || (v.SetOfMaps != nil && rhs.SetOfMaps != nil && _Set_Map_String_String_sliceType_Equals(v.SetOfMaps, rhs.SetOfMaps))) {
		return false
	}
	if !((v.MapOfMapToInt == nil && rhs.MapOfMapToInt == nil) || (v.MapOfMapToInt != nil && rhs.MapOfMapToInt != nil && _Map_Map_String_I32_I64_Equals(v.MapOfMapToInt, rhs.MapOfMapToInt))) {
		return false
	}
	if !((v.MapOfListToSet == nil && rhs.MapOfListToSet == nil) || (v.MapOfListToSet != nil && rhs.MapOfListToSet != nil && _Map_List_I32_Set_I64_mapType_Equals(v.MapOfListToSet, rhs.MapOfListToSet))) {
		return false
	}
	if !((v.MapOfSetToListOfDouble == nil && rhs.MapOfSetToListOfDouble == nil) || (v.MapOfSetToListOfDouble != nil && rhs.MapOfSetToListOfDouble != nil && _Map_Set_I32_mapType_List_Double_Equals(v.MapOfSetToListOfDouble, rhs.MapOfSetToListOfDouble))) {
		return false
	}

	return true
}

type _List_I32_Zapper []int32

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

type _List_List_I32_Zapper [][]int32

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

type _Set_I32_mapType_Zapper map[int32]struct{}

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

type _List_Set_I32_mapType_Zapper []map[int32]struct{}

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

type _Map_I32_I32_Item_Zapper struct {
	Key   int32
	Value int32
}

// MarshalLogArray implements zapcore.ArrayMarshaler, enabling
// fast logging of _Map_I32_I32_Item_Zapper.
func (v _Map_I32_I32_Item_Zapper) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
	enc.AddInt32("key", v.Key)
	enc.AddInt32("value", v.Value)
	return err
}

type _Map_I32_I32_Zapper map[int32]int32

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

type _List_Map_I32_I32_Zapper []map[int32]int32

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

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
}

type _Set_Set_String_mapType_sliceType_Zapper []map[string]struct{}

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

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
}

type _Set_List_String_sliceType_Zapper [][]string

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

type _Map_String_String_Zapper map[string]string

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

type _Set_Map_String_String_sliceType_Zapper []map[string]string

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

type _Map_String_I32_Zapper map[string]int32

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

type _Map_Map_String_I32_I64_Item_Zapper struct {
	Key   map[string]int32
	Value int64
}

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

type _Map_Map_String_I32_I64_Zapper []struct {
	Key   map[string]int32
	Value int64
}

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

type _Set_I64_mapType_Zapper map[int64]struct{}

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

type _Map_List_I32_Set_I64_mapType_Item_Zapper struct {
	Key   []int32
	Value map[int64]struct{}
}

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

type _Map_List_I32_Set_I64_mapType_Zapper []struct {
	Key   []int32
	Value map[int64]struct{}
}

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

type _List_Double_Zapper []float64

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

type _Map_Set_I32_mapType_List_Double_Item_Zapper struct {
	Key   map[int32]struct{}
	Value []float64
}

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

type _Map_Set_I32_mapType_List_Double_Zapper []struct {
	Key   map[int32]struct{}
	Value []float64
}

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

// MarshalLogObject implements zapcore.ObjectMarshaler, enabling
// fast logging of ContainersOfContainers.
func (v *ContainersOfContainers) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
	if v == nil {
		return nil
	}
	if v.ListOfLists != nil {
		err = multierr.Append(err, enc.AddArray("listOfLists", (_List_List_I32_Zapper)(v.ListOfLists)))
	}
	if v.ListOfSets != nil {
		err = multierr.Append(err, enc.AddArray("listOfSets", (_List_Set_I32_mapType_Zapper)(v.ListOfSets)))
	}
	if v.ListOfMaps != nil {
		err = multierr.Append(err, enc.AddArray("listOfMaps", (_List_Map_I32_I32_Zapper)(v.ListOfMaps)))
	}
	if v.SetOfSets != nil {
		err = multierr.Append(err, enc.AddArray("setOfSets", (_Set_Set_String_mapType_sliceType_Zapper)(v.SetOfSets)))
	}
	if v.SetOfLists != nil {
		err = multierr.Append(err, enc.AddArray("setOfLists", (_Set_List_String_sliceType_Zapper)(v.SetOfLists)))
	}
	if v.SetOfMaps != nil {
		err = multierr.Append(err, enc.AddArray("setOfMaps", (_Set_Map_String_String_sliceType_Zapper)(v.SetOfMaps)))
	}
	if v.MapOfMapToInt != nil {
		err = multierr.Append(err, enc.AddArray("mapOfMapToInt", (_Map_Map_String_I32_I64_Zapper)(v.MapOfMapToInt)))
	}
	if v.MapOfListToSet != nil {
		err = multierr.Append(err, enc.AddArray("mapOfListToSet", (_Map_List_I32_Set_I64_mapType_Zapper)(v.MapOfListToSet)))
	}
	if v.MapOfSetToListOfDouble != nil {
		err = multierr.Append(err, enc.AddArray("mapOfSetToListOfDouble", (_Map_Set_I32_mapType_List_Double_Zapper)(v.MapOfSetToListOfDouble)))
	}
	return err
}

// GetListOfLists returns the value of ListOfLists if it is set or its
// zero value if it is unset.
func (v *ContainersOfContainers) GetListOfLists() (o [][]int32) {
	if v != nil && v.ListOfLists != nil {
		return v.ListOfLists
	}

	return
}

// IsSetListOfLists returns true if ListOfLists is not nil.
func (v *ContainersOfContainers) IsSetListOfLists() bool {
	return v != nil && v.ListOfLists != nil
}

// GetListOfSets returns the value of ListOfSets if it is set or its
// zero value if it is unset.
func (v *ContainersOfContainers) GetListOfSets() (o []map[int32]struct{}) {
	if v != nil && v.ListOfSets != nil {
		return v.ListOfSets
	}

	return
}

// IsSetListOfSets returns true if ListOfSets is not nil.
func (v *ContainersOfContainers) IsSetListOfSets() bool {
	return v != nil && v.ListOfSets != nil
}

// GetListOfMaps returns the value of ListOfMaps if it is set or its
// zero value if it is unset.
func (v *ContainersOfContainers) GetListOfMaps() (o []map[int32]int32) {
	if v != nil && v.ListOfMaps != nil {
		return v.ListOfMaps
	}

	return
}

// IsSetListOfMaps returns true if ListOfMaps is not nil.
func (v *ContainersOfContainers) IsSetListOfMaps() bool {
	return v != nil && v.ListOfMaps != nil
}

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

	return
}

// IsSetSetOfSets returns true if SetOfSets is not nil.
func (v *ContainersOfContainers) IsSetSetOfSets() bool {
	return v != nil && v.SetOfSets != nil
}

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

	return
}

// IsSetSetOfLists returns true if SetOfLists is not nil.
func (v *ContainersOfContainers) IsSetSetOfLists() bool {
	return v != nil && v.SetOfLists != nil
}

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

	return
}

// IsSetSetOfMaps returns true if SetOfMaps is not nil.
func (v *ContainersOfContainers) IsSetSetOfMaps() bool {
	return v != nil && v.SetOfMaps != nil
}

// GetMapOfMapToInt returns the value of MapOfMapToInt if it is set or its
// zero value if it is unset.
func (v *ContainersOfContainers) GetMapOfMapToInt() (o []struct {
	Key   map[string]int32
	Value int64
}) {
	if v != nil && v.MapOfMapToInt != nil {
		return v.MapOfMapToInt
	}

	return
}

// IsSetMapOfMapToInt returns true if MapOfMapToInt is not nil.
func (v *ContainersOfContainers) IsSetMapOfMapToInt() bool {
	return v != nil && v.MapOfMapToInt != nil
}

// GetMapOfListToSet returns the value of MapOfListToSet if it is set or its
// zero value if it is unset.
func (v *ContainersOfContainers) GetMapOfListToSet() (o []struct {
	Key   []int32
	Value map[int64]struct{}
}) {
	if v != nil && v.MapOfListToSet != nil {
		return v.MapOfListToSet
	}

	return
}

// IsSetMapOfListToSet returns true if MapOfListToSet is not nil.
func (v *ContainersOfContainers) IsSetMapOfListToSet() bool {
	return v != nil && v.MapOfListToSet != nil
}

// GetMapOfSetToListOfDouble returns the value of MapOfSetToListOfDouble if it is set or its
// zero value if it is unset.
func (v *ContainersOfContainers) GetMapOfSetToListOfDouble() (o []struct {
	Key   map[int32]struct{}
	Value []float64
}) {
	if v != nil && v.MapOfSetToListOfDouble != nil {
		return v.MapOfSetToListOfDouble
	}

	return
}

// IsSetMapOfSetToListOfDouble returns true if MapOfSetToListOfDouble is not nil.
func (v *ContainersOfContainers) IsSetMapOfSetToListOfDouble() bool {
	return v != nil && v.MapOfSetToListOfDouble != nil
}

type EnumContainers struct {
	ListOfEnums []enums.EnumDefault                     `json:"listOfEnums,omitempty"`
	SetOfEnums  map[enums.EnumWithValues]struct{}       `json:"setOfEnums,omitempty"`
	MapOfEnums  map[enums.EnumWithDuplicateValues]int32 `json:"mapOfEnums,omitempty"`
}

type _List_EnumDefault_ValueList []enums.EnumDefault

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

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

func (_List_EnumDefault_ValueList) ValueType() wire.Type {
	return wire.TI32
}

func (_List_EnumDefault_ValueList) Close() {}

type _Set_EnumWithValues_mapType_ValueList map[enums.EnumWithValues]struct{}

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

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

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

func (_Set_EnumWithValues_mapType_ValueList) ValueType() wire.Type {
	return wire.TI32
}

func (_Set_EnumWithValues_mapType_ValueList) Close() {}

type _Map_EnumWithDuplicateValues_I32_MapItemList map[enums.EnumWithDuplicateValues]int32

func (m _Map_EnumWithDuplicateValues_I32_MapItemList) ForEach(f func(wire.MapItem) error) error {
	for k, v := range m {
		kw, err := k.ToWire()
		if err != nil {
			return err
		}

		vw, err := wire.NewValueI32(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_EnumWithDuplicateValues_I32_MapItemList) Size() int {
	return len(m)
}

func (_Map_EnumWithDuplicateValues_I32_MapItemList) KeyType() wire.Type {
	return wire.TI32
}

func (_Map_EnumWithDuplicateValues_I32_MapItemList) ValueType() wire.Type {
	return wire.TI32
}

func (_Map_EnumWithDuplicateValues_I32_MapItemList) Close() {}

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

	if v.ListOfEnums != nil {
		w, err = wire.NewValueList(_List_EnumDefault_ValueList(v.ListOfEnums)), error(nil)
		if err != nil {
			return w, err
		}
		fields[i] = wire.Field{ID: 1, Value: w}
		i++
	}
	if v.SetOfEnums != nil {
		w, err = wire.NewValueSet(_Set_EnumWithValues_mapType_ValueList(v.SetOfEnums)), error(nil)
		if err != nil {
			return w, err
		}
		fields[i] = wire.Field{ID: 2, Value: w}
		i++
	}
	if v.MapOfEnums != nil {
		w, err = wire.NewValueMap(_Map_EnumWithDuplicateValues_I32_MapItemList(v.MapOfEnums)), 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
}

func _EnumDefault_Read(w wire.Value) (enums.EnumDefault, error) {
	var v enums.EnumDefault
	err := v.FromWire(w)
	return v, err
}

func _List_EnumDefault_Read(l wire.ValueList) ([]enums.EnumDefault, error) {
	if l.ValueType() != wire.TI32 {
		return nil, nil
	}

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

func _EnumWithValues_Read(w wire.Value) (enums.EnumWithValues, error) {
	var v enums.EnumWithValues
	err := v.FromWire(w)
	return v, err
}

func _Set_EnumWithValues_mapType_Read(s wire.ValueList) (map[enums.EnumWithValues]struct{}, error) {
	if s.ValueType() != wire.TI32 {
		return nil, nil
	}

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

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

func _EnumWithDuplicateValues_Read(w wire.Value) (enums.EnumWithDuplicateValues, error) {
	var v enums.EnumWithDuplicateValues
	err := v.FromWire(w)
	return v, err
}

func _Map_EnumWithDuplicateValues_I32_Read(m wire.MapItemList) (map[enums.EnumWithDuplicateValues]int32, error) {
	if m.KeyType() != wire.TI32 {
		return nil, nil
	}

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

	o := make(map[enums.EnumWithDuplicateValues]int32, m.Size())
	err := m.ForEach(func(x wire.MapItem) error {
		k, err := _EnumWithDuplicateValues_Read(x.Key)
		if err != nil {
			return err
		}

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

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

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

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

			}
		case 2:
			if field.Value.Type() == wire.TSet {
				v.SetOfEnums, err = _Set_EnumWithValues_mapType_Read(field.Value.GetSet())
				if err != nil {
					return err
				}

			}
		case 3:
			if field.Value.Type() == wire.TMap {
				v.MapOfEnums, err = _Map_EnumWithDuplicateValues_I32_Read(field.Value.GetMap())
				if err != nil {
					return err
				}

			}
		}
	}

	return nil
}

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

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

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

func _List_EnumDefault_Equals(lhs, rhs []enums.EnumDefault) bool {
	if len(lhs) != len(rhs) {
		return false
	}

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

	return true
}

func _Set_EnumWithValues_mapType_Equals(lhs, rhs map[enums.EnumWithValues]struct{}) bool {
	if len(lhs) != len(rhs) {
		return false
	}

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

	return true
}

func _Map_EnumWithDuplicateValues_I32_Equals(lhs, rhs map[enums.EnumWithDuplicateValues]int32) bool {
	if len(lhs) != len(rhs) {
		return false
	}

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

// Equals returns true if all the fields of this EnumContainers match the
// provided EnumContainers.
//
// This function performs a deep comparison.
func (v *EnumContainers) Equals(rhs *EnumContainers) bool {
	if v == nil {
		return rhs == nil
	} else if rhs == nil {
		return false
	}
	if !((v.ListOfEnums == nil && rhs.ListOfEnums == nil) || (v.ListOfEnums != nil && rhs.ListOfEnums != nil && _List_EnumDefault_Equals(v.ListOfEnums, rhs.ListOfEnums))) {
		return false
	}
	if !((v.SetOfEnums == nil && rhs.SetOfEnums == nil) || (v.SetOfEnums != nil && rhs.SetOfEnums != nil && _Set_EnumWithValues_mapType_Equals(v.SetOfEnums, rhs.SetOfEnums))) {
		return false
	}
	if !((v.MapOfEnums == nil && rhs.MapOfEnums == nil) || (v.MapOfEnums != nil && rhs.MapOfEnums != nil && _Map_EnumWithDuplicateValues_I32_Equals(v.MapOfEnums, rhs.MapOfEnums))) {
		return false
	}

	return true
}

type _List_EnumDefault_Zapper []enums.EnumDefault

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

type _Set_EnumWithValues_mapType_Zapper map[enums.EnumWithValues]struct{}

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

type _Map_EnumWithDuplicateValues_I32_Item_Zapper struct {
	Key   enums.EnumWithDuplicateValues
	Value int32
}

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

type _Map_EnumWithDuplicateValues_I32_Zapper map[enums.EnumWithDuplicateValues]int32

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

// MarshalLogObject implements zapcore.ObjectMarshaler, enabling
// fast logging of EnumContainers.
func (v *EnumContainers) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
	if v == nil {
		return nil
	}
	if v.ListOfEnums != nil {
		err = multierr.Append(err, enc.AddArray("listOfEnums", (_List_EnumDefault_Zapper)(v.ListOfEnums)))
	}
	if v.SetOfEnums != nil {
		err = multierr.Append(err, enc.AddArray("setOfEnums", (_Set_EnumWithValues_mapType_Zapper)(v.SetOfEnums)))
	}
	if v.MapOfEnums != nil {
		err = multierr.Append(err, enc.AddArray("mapOfEnums", (_Map_EnumWithDuplicateValues_I32_Zapper)(v.MapOfEnums)))
	}
	return err
}

// GetListOfEnums returns the value of ListOfEnums if it is set or its
// zero value if it is unset.
func (v *EnumContainers) GetListOfEnums() (o []enums.EnumDefault) {
	if v != nil && v.ListOfEnums != nil {
		return v.ListOfEnums
	}

	return
}

// IsSetListOfEnums returns true if ListOfEnums is not nil.
func (v *EnumContainers) IsSetListOfEnums() bool {
	return v != nil && v.ListOfEnums != nil
}

// GetSetOfEnums returns the value of SetOfEnums if it is set or its
// zero value if it is unset.
func (v *EnumContainers) GetSetOfEnums() (o map[enums.EnumWithValues]struct{}) {
	if v != nil && v.SetOfEnums != nil {
		return v.SetOfEnums
	}

	return
}

// IsSetSetOfEnums returns true if SetOfEnums is not nil.
func (v *EnumContainers) IsSetSetOfEnums() bool {
	return v != nil && v.SetOfEnums != nil
}

// GetMapOfEnums returns the value of MapOfEnums if it is set or its
// zero value if it is unset.
func (v *EnumContainers) GetMapOfEnums() (o map[enums.EnumWithDuplicateValues]int32) {
	if v != nil && v.MapOfEnums != nil {
		return v.MapOfEnums
	}

	return
}

// IsSetMapOfEnums returns true if MapOfEnums is not nil.
func (v *EnumContainers) IsSetMapOfEnums() bool {
	return v != nil && v.MapOfEnums != nil
}

type ListOfConflictingEnums struct {
	Records      []enum_conflict.RecordType `json:"records,required"`
	OtherRecords []enums.RecordType         `json:"otherRecords,required"`
}

type _List_RecordType_ValueList []enum_conflict.RecordType

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

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

func (_List_RecordType_ValueList) ValueType() wire.Type {
	return wire.TI32
}

func (_List_RecordType_ValueList) Close() {}

type _List_RecordType_1_ValueList []enums.RecordType

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

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

func (_List_RecordType_1_ValueList) ValueType() wire.Type {
	return wire.TI32
}

func (_List_RecordType_1_ValueList) Close() {}

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

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

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

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

func _RecordType_Read(w wire.Value) (enum_conflict.RecordType, error) {
	var v enum_conflict.RecordType
	err := v.FromWire(w)
	return v, err
}

func _List_RecordType_Read(l wire.ValueList) ([]enum_conflict.RecordType, error) {
	if l.ValueType() != wire.TI32 {
		return nil, nil
	}

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

func _RecordType_1_Read(w wire.Value) (enums.RecordType, error) {
	var v enums.RecordType
	err := v.FromWire(w)
	return v, err
}

func _List_RecordType_1_Read(l wire.ValueList) ([]enums.RecordType, error) {
	if l.ValueType() != wire.TI32 {
		return nil, nil
	}

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

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

	recordsIsSet := false
	otherRecordsIsSet := false

	for _, field := range w.GetStruct().Fields {
		switch field.ID {
		case 1:
			if field.Value.Type() == wire.TList {
				v.Records, err = _List_RecordType_Read(field.Value.GetList())
				if err != nil {
					return err
				}
				recordsIsSet = true
			}
		case 2:
			if field.Value.Type() == wire.TList {
				v.OtherRecords, err = _List_RecordType_1_Read(field.Value.GetList())
				if err != nil {
					return err
				}
				otherRecordsIsSet = true
			}
		}
	}

	if !recordsIsSet {
		return errors.New("field Records of ListOfConflictingEnums is required")
	}

	if !otherRecordsIsSet {
		return errors.New("field OtherRecords of ListOfConflictingEnums is required")
	}

	return nil
}

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

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

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

func _List_RecordType_Equals(lhs, rhs []enum_conflict.RecordType) bool {
	if len(lhs) != len(rhs) {
		return false
	}

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

	return true
}

func _List_RecordType_1_Equals(lhs, rhs []enums.RecordType) 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 ListOfConflictingEnums match the
// provided ListOfConflictingEnums.
//
// This function performs a deep comparison.
func (v *ListOfConflictingEnums) Equals(rhs *ListOfConflictingEnums) bool {
	if v == nil {
		return rhs == nil
	} else if rhs == nil {
		return false
	}
	if !_List_RecordType_Equals(v.Records, rhs.Records) {
		return false
	}
	if !_List_RecordType_1_Equals(v.OtherRecords, rhs.OtherRecords) {
		return false
	}

	return true
}

type _List_RecordType_Zapper []enum_conflict.RecordType

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

type _List_RecordType_1_Zapper []enums.RecordType

// MarshalLogArray implements zapcore.ArrayMarshaler, enabling
// fast logging of _List_RecordType_1_Zapper.
func (l _List_RecordType_1_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 ListOfConflictingEnums.
func (v *ListOfConflictingEnums) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
	if v == nil {
		return nil
	}
	err = multierr.Append(err, enc.AddArray("records", (_List_RecordType_Zapper)(v.Records)))
	err = multierr.Append(err, enc.AddArray("otherRecords", (_List_RecordType_1_Zapper)(v.OtherRecords)))
	return err
}

// GetRecords returns the value of Records if it is set or its
// zero value if it is unset.
func (v *ListOfConflictingEnums) GetRecords() (o []enum_conflict.RecordType) {
	if v != nil {
		o = v.Records
	}
	return
}

// IsSetRecords returns true if Records is not nil.
func (v *ListOfConflictingEnums) IsSetRecords() bool {
	return v != nil && v.Records != nil
}

// GetOtherRecords returns the value of OtherRecords if it is set or its
// zero value if it is unset.
func (v *ListOfConflictingEnums) GetOtherRecords() (o []enums.RecordType) {
	if v != nil {
		o = v.OtherRecords
	}
	return
}

// IsSetOtherRecords returns true if OtherRecords is not nil.
func (v *ListOfConflictingEnums) IsSetOtherRecords() bool {
	return v != nil && v.OtherRecords != nil
}

type ListOfConflictingUUIDs struct {
	Uuids      []*typedefs.UUID     `json:"uuids,required"`
	OtherUUIDs []uuid_conflict.UUID `json:"otherUUIDs,required"`
}

type _List_UUID_ValueList []*typedefs.UUID

func (v _List_UUID_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_UUID_ValueList) Size() int {
	return len(v)
}

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

func (_List_UUID_ValueList) Close() {}

type _List_UUID_1_ValueList []uuid_conflict.UUID

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

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

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

func (_List_UUID_1_ValueList) Close() {}

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

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

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

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

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

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

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

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

func _List_UUID_1_Read(l wire.ValueList) ([]uuid_conflict.UUID, error) {
	if l.ValueType() != wire.TBinary {
		return nil, nil
	}

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

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

	uuidsIsSet := false
	otherUUIDsIsSet := false

	for _, field := range w.GetStruct().Fields {
		switch field.ID {
		case 1:
			if field.Value.Type() == wire.TList {
				v.Uuids, err = _List_UUID_Read(field.Value.GetList())
				if err != nil {
					return err
				}
				uuidsIsSet = true
			}
		case 2:
			if field.Value.Type() == wire.TList {
				v.OtherUUIDs, err = _List_UUID_1_Read(field.Value.GetList())
				if err != nil {
					return err
				}
				otherUUIDsIsSet = true
			}
		}
	}

	if !uuidsIsSet {
		return errors.New("field Uuids of ListOfConflictingUUIDs is required")
	}

	if !otherUUIDsIsSet {
		return errors.New("field OtherUUIDs of ListOfConflictingUUIDs is required")
	}

	return nil
}

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

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

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

func _List_UUID_Equals(lhs, rhs []*typedefs.UUID) bool {
	if len(lhs) != len(rhs) {
		return false
	}

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

	return true
}

func _List_UUID_1_Equals(lhs, rhs []uuid_conflict.UUID) 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 ListOfConflictingUUIDs match the
// provided ListOfConflictingUUIDs.
//
// This function performs a deep comparison.
func (v *ListOfConflictingUUIDs) Equals(rhs *ListOfConflictingUUIDs) bool {
	if v == nil {
		return rhs == nil
	} else if rhs == nil {
		return false
	}
	if !_List_UUID_Equals(v.Uuids, rhs.Uuids) {
		return false
	}
	if !_List_UUID_1_Equals(v.OtherUUIDs, rhs.OtherUUIDs) {
		return false
	}

	return true
}

type _List_UUID_Zapper []*typedefs.UUID

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

type _List_UUID_1_Zapper []uuid_conflict.UUID

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

// MarshalLogObject implements zapcore.ObjectMarshaler, enabling
// fast logging of ListOfConflictingUUIDs.
func (v *ListOfConflictingUUIDs) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
	if v == nil {
		return nil
	}
	err = multierr.Append(err, enc.AddArray("uuids", (_List_UUID_Zapper)(v.Uuids)))
	err = multierr.Append(err, enc.AddArray("otherUUIDs", (_List_UUID_1_Zapper)(v.OtherUUIDs)))
	return err
}

// GetUuids returns the value of Uuids if it is set or its
// zero value if it is unset.
func (v *ListOfConflictingUUIDs) GetUuids() (o []*typedefs.UUID) {
	if v != nil {
		o = v.Uuids
	}
	return
}

// IsSetUuids returns true if Uuids is not nil.
func (v *ListOfConflictingUUIDs) IsSetUuids() bool {
	return v != nil && v.Uuids != nil
}

// GetOtherUUIDs returns the value of OtherUUIDs if it is set or its
// zero value if it is unset.
func (v *ListOfConflictingUUIDs) GetOtherUUIDs() (o []uuid_conflict.UUID) {
	if v != nil {
		o = v.OtherUUIDs
	}
	return
}

// IsSetOtherUUIDs returns true if OtherUUIDs is not nil.
func (v *ListOfConflictingUUIDs) IsSetOtherUUIDs() bool {
	return v != nil && v.OtherUUIDs != nil
}

type ListOfOptionalPrimitives struct {
	ListOfStrings []string `json:"listOfStrings,omitempty"`
}

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

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

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

			}
		}
	}

	return nil
}

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

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

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

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

	return true
}

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

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

	return
}

// IsSetListOfStrings returns true if ListOfStrings is not nil.
func (v *ListOfOptionalPrimitives) IsSetListOfStrings() bool {
	return v != nil && v.ListOfStrings != nil
}

type ListOfRequiredPrimitives struct {
	ListOfStrings []string `json:"listOfStrings,required"`
}

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

	listOfStringsIsSet := false

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

	if !listOfStringsIsSet {
		return errors.New("field ListOfStrings of ListOfRequiredPrimitives is required")
	}

	return nil
}

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

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

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

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

	return true
}

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

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

// IsSetListOfStrings returns true if ListOfStrings is not nil.
func (v *ListOfRequiredPrimitives) IsSetListOfStrings() bool {
	return v != nil && v.ListOfStrings != nil
}

type MapOfBinaryAndString struct {
	BinaryToString []struct {
		Key   []byte
		Value string
	} `json:"binaryToString,omitempty"`
	StringToBinary map[string][]byte `json:"stringToBinary,omitempty"`
}

type _Map_Binary_String_MapItemList []struct {
	Key   []byte
	Value string
}

func (m _Map_Binary_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 := wire.NewValueBinary(k), error(nil)
		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_Binary_String_MapItemList) Size() int {
	return len(m)
}

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

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

func (_Map_Binary_String_MapItemList) Close() {}

type _Map_String_Binary_MapItemList map[string][]byte

func (m _Map_String_Binary_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 := wire.NewValueBinary(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_String_Binary_MapItemList) Size() int {
	return len(m)
}

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

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

func (_Map_String_Binary_MapItemList) Close() {}

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

	if v.BinaryToString != nil {
		w, err = wire.NewValueMap(_Map_Binary_String_MapItemList(v.BinaryToString)), error(nil)
		if err != nil {
			return w, err
		}
		fields[i] = wire.Field{ID: 1, Value: w}
		i++
	}
	if v.StringToBinary != nil {
		w, err = wire.NewValueMap(_Map_String_Binary_MapItemList(v.StringToBinary)), error(nil)
		if err != nil {
			return w, err
		}
		fields[i] = wire.Field{ID: 2, Value: w}
		i++
	}

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

func _Map_Binary_String_Read(m wire.MapItemList) ([]struct {
	Key   []byte
	Value string
}, error) {
	if m.KeyType() != wire.TBinary {
		return nil, nil
	}

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

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

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

		o = append(o, struct {
			Key   []byte
			Value string
		}{k, v})
		return nil
	})
	m.Close()
	return o, err
}

func _Map_String_Binary_Read(m wire.MapItemList) (map[string][]byte, error) {
	if m.KeyType() != wire.TBinary {
		return nil, nil
	}

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

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

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

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

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

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

			}
		case 2:
			if field.Value.Type() == wire.TMap {
				v.StringToBinary, err = _Map_String_Binary_Read(field.Value.GetMap())
				if err != nil {
					return err
				}

			}
		}
	}

	return nil
}

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

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

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

func _Map_Binary_String_Equals(lhs, rhs []struct {
	Key   []byte
	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 !bytes.Equal(lk, rk) {
				continue
			}

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

		if !ok {
			return false
		}
	}
	return true
}

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

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

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

	return true
}

type _Map_Binary_String_Item_Zapper struct {
	Key   []byte
	Value string
}

// MarshalLogArray implements zapcore.ArrayMarshaler, enabling
// fast logging of _Map_Binary_String_Item_Zapper.
func (v _Map_Binary_String_Item_Zapper) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
	enc.AddString("key", base64.StdEncoding.EncodeToString(v.Key))
	enc.AddString("value", v.Value)
	return err
}

type _Map_Binary_String_Zapper []struct {
	Key   []byte
	Value string
}

// MarshalLogArray implements zapcore.ArrayMarshaler, enabling
// fast logging of _Map_Binary_String_Zapper.
func (m _Map_Binary_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_Binary_String_Item_Zapper{Key: k, Value: v}))
	}
	return err
}

type _Map_String_Binary_Zapper map[string][]byte

// MarshalLogObject implements zapcore.ObjectMarshaler, enabling
// fast logging of _Map_String_Binary_Zapper.
func (m _Map_String_Binary_Zapper) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
	for k, v := range m {
		enc.AddString((string)(k), base64.StdEncoding.EncodeToString(v))
	}
	return err
}

// MarshalLogObject implements zapcore.ObjectMarshaler, enabling
// fast logging of MapOfBinaryAndString.
func (v *MapOfBinaryAndString) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
	if v == nil {
		return nil
	}
	if v.BinaryToString != nil {
		err = multierr.Append(err, enc.AddArray("binaryToString", (_Map_Binary_String_Zapper)(v.BinaryToString)))
	}
	if v.StringToBinary != nil {
		err = multierr.Append(err, enc.AddObject("stringToBinary", (_Map_String_Binary_Zapper)(v.StringToBinary)))
	}
	return err
}

// GetBinaryToString returns the value of BinaryToString if it is set or its
// zero value if it is unset.
func (v *MapOfBinaryAndString) GetBinaryToString() (o []struct {
	Key   []byte
	Value string
}) {
	if v != nil && v.BinaryToString != nil {
		return v.BinaryToString
	}

	return
}

// IsSetBinaryToString returns true if BinaryToString is not nil.
func (v *MapOfBinaryAndString) IsSetBinaryToString() bool {
	return v != nil && v.BinaryToString != nil
}

// GetStringToBinary returns the value of StringToBinary if it is set or its
// zero value if it is unset.
func (v *MapOfBinaryAndString) GetStringToBinary() (o map[string][]byte) {
	if v != nil && v.StringToBinary != nil {
		return v.StringToBinary
	}

	return
}

// IsSetStringToBinary returns true if StringToBinary is not nil.
func (v *MapOfBinaryAndString) IsSetStringToBinary() bool {
	return v != nil && v.StringToBinary != nil
}

type PrimitiveContainers struct {
	ListOfBinary      [][]byte            `json:"listOfBinary,omitempty"`
	ListOfInts        []int64             `json:"listOfInts,omitempty"`
	SetOfStrings      map[string]struct{} `json:"setOfStrings,omitempty"`
	SetOfBytes        map[int8]struct{}   `json:"setOfBytes,omitempty"`
	MapOfIntToString  map[int32]string    `json:"mapOfIntToString,omitempty"`
	MapOfStringToBool map[string]bool     `json:"mapOfStringToBool,omitempty"`
}

type _List_Binary_ValueList [][]byte

func (v _List_Binary_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 := wire.NewValueBinary(x), error(nil)
		if err != nil {
			return err
		}
		err = f(w)
		if err != nil {
			return err
		}
	}
	return nil
}

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

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

func (_List_Binary_ValueList) Close() {}

type _List_I64_ValueList []int64

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

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

func (_List_I64_ValueList) ValueType() wire.Type {
	return wire.TI64
}

func (_List_I64_ValueList) Close() {}

type _Set_Byte_mapType_ValueList map[int8]struct{}

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

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

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

func (_Set_Byte_mapType_ValueList) ValueType() wire.Type {
	return wire.TI8
}

func (_Set_Byte_mapType_ValueList) Close() {}

type _Map_I32_String_MapItemList map[int32]string

func (m _Map_I32_String_MapItemList) ForEach(f func(wire.MapItem) error) error {
	for k, v := range m {
		kw, err := wire.NewValueI32(k), error(nil)
		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_I32_String_MapItemList) Size() int {
	return len(m)
}

func (_Map_I32_String_MapItemList) KeyType() wire.Type {
	return wire.TI32
}

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

func (_Map_I32_String_MapItemList) Close() {}

type _Map_String_Bool_MapItemList map[string]bool

func (m _Map_String_Bool_MapItemList) ForEach(f func(wire.MapItem) error) error {
	for k, v := range m {
		kw, err := wire.NewValueString(k), error(nil)
		if err != nil {
			return err
		}

		vw, err := wire.NewValueBool(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_String_Bool_MapItemList) Size() int {
	return len(m)
}

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

func (_Map_String_Bool_MapItemList) ValueType() wire.Type {
	return wire.TBool
}

func (_Map_String_Bool_MapItemList) Close() {}

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

	if v.ListOfBinary != nil {
		w, err = wire.NewValueList(_List_Binary_ValueList(v.ListOfBinary)), error(nil)
		if err != nil {
			return w, err
		}
		fields[i] = wire.Field{ID: 1, Value: w}
		i++
	}
	if v.ListOfInts != nil {
		w, err = wire.NewValueList(_List_I64_ValueList(v.ListOfInts)), error(nil)
		if err != nil {
			return w, err
		}
		fields[i] = wire.Field{ID: 2, Value: w}
		i++
	}
	if v.SetOfStrings != nil {
		w, err = wire.NewValueSet(_Set_String_mapType_ValueList(v.SetOfStrings)), error(nil)
		if err != nil {
			return w, err
		}
		fields[i] = wire.Field{ID: 3, Value: w}
		i++
	}
	if v.SetOfBytes != nil {
		w, err = wire.NewValueSet(_Set_Byte_mapType_ValueList(v.SetOfBytes)), error(nil)
		if err != nil {
			return w, err
		}
		fields[i] = wire.Field{ID: 4, Value: w}
		i++
	}
	if v.MapOfIntToString != nil {
		w, err = wire.NewValueMap(_Map_I32_String_MapItemList(v.MapOfIntToString)), error(nil)
		if err != nil {
			return w, err
		}
		fields[i] = wire.Field{ID: 5, Value: w}
		i++
	}
	if v.MapOfStringToBool != nil {
		w, err = wire.NewValueMap(_Map_String_Bool_MapItemList(v.MapOfStringToBool)), error(nil)
		if err != nil {
			return w, err
		}
		fields[i] = wire.Field{ID: 6, Value: w}
		i++
	}

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

func _List_Binary_Read(l wire.ValueList) ([][]byte, error) {
	if l.ValueType() != wire.TBinary {
		return nil, nil
	}

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

func _List_I64_Read(l wire.ValueList) ([]int64, error) {
	if l.ValueType() != wire.TI64 {
		return nil, nil
	}

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

func _Set_Byte_mapType_Read(s wire.ValueList) (map[int8]struct{}, error) {
	if s.ValueType() != wire.TI8 {
		return nil, nil
	}

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

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

func _Map_I32_String_Read(m wire.MapItemList) (map[int32]string, error) {
	if m.KeyType() != wire.TI32 {
		return nil, nil
	}

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

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

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

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

func _Map_String_Bool_Read(m wire.MapItemList) (map[string]bool, error) {
	if m.KeyType() != wire.TBinary {
		return nil, nil
	}

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

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

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

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

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

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

			}
		case 2:
			if field.Value.Type() == wire.TList {
				v.ListOfInts, err = _List_I64_Read(field.Value.GetList())
				if err != nil {
					return err
				}

			}
		case 3:
			if field.Value.Type() == wire.TSet {
				v.SetOfStrings, err = _Set_String_mapType_Read(field.Value.GetSet())
				if err != nil {
					return err
				}

			}
		case 4:
			if field.Value.Type() == wire.TSet {
				v.SetOfBytes, err = _Set_Byte_mapType_Read(field.Value.GetSet())
				if err != nil {
					return err
				}

			}
		case 5:
			if field.Value.Type() == wire.TMap {
				v.MapOfIntToString, err = _Map_I32_String_Read(field.Value.GetMap())
				if err != nil {
					return err
				}

			}
		case 6:
			if field.Value.Type() == wire.TMap {
				v.MapOfStringToBool, err = _Map_String_Bool_Read(field.Value.GetMap())
				if err != nil {
					return err
				}

			}
		}
	}

	return nil
}

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

	var fields [6]string
	i := 0
	if v.ListOfBinary != nil {
		fields[i] = fmt.Sprintf("ListOfBinary: %v", v.ListOfBinary)
		i++
	}
	if v.ListOfInts != nil {
		fields[i] = fmt.Sprintf("ListOfInts: %v", v.ListOfInts)
		i++
	}
	if v.SetOfStrings != nil {
		fields[i] = fmt.Sprintf("SetOfStrings: %v", v.SetOfStrings)
		i++
	}
	if v.SetOfBytes != nil {
		fields[i] = fmt.Sprintf("SetOfBytes: %v", v.SetOfBytes)
		i++
	}
	if v.MapOfIntToString != nil {
		fields[i] = fmt.Sprintf("MapOfIntToString: %v", v.MapOfIntToString)
		i++
	}
	if v.MapOfStringToBool != nil {
		fields[i] = fmt.Sprintf("MapOfStringToBool: %v", v.MapOfStringToBool)
		i++
	}

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

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

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

	return true
}

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

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

	return true
}

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

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

	return true
}

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

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

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

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

// Equals returns true if all the fields of this PrimitiveContainers match the
// provided PrimitiveContainers.
//
// This function performs a deep comparison.
func (v *PrimitiveContainers) Equals(rhs *PrimitiveContainers) bool {
	if v == nil {
		return rhs == nil
	} else if rhs == nil {
		return false
	}
	if !((v.ListOfBinary == nil && rhs.ListOfBinary == nil) || (v.ListOfBinary != nil && rhs.ListOfBinary != nil && _List_Binary_Equals(v.ListOfBinary, rhs.ListOfBinary))) {
		return false
	}
	if !((v.ListOfInts == nil && rhs.ListOfInts == nil) || (v.ListOfInts != nil && rhs.ListOfInts != nil && _List_I64_Equals(v.ListOfInts, rhs.ListOfInts))) {
		return false
	}
	if !((v.SetOfStrings == nil && rhs.SetOfStrings == nil) || (v.SetOfStrings != nil && rhs.SetOfStrings != nil && _Set_String_mapType_Equals(v.SetOfStrings, rhs.SetOfStrings))) {
		return false
	}
	if !((v.SetOfBytes == nil && rhs.SetOfBytes == nil) || (v.SetOfBytes != nil && rhs.SetOfBytes != nil && _Set_Byte_mapType_Equals(v.SetOfBytes, rhs.SetOfBytes))) {
		return false
	}
	if !((v.MapOfIntToString == nil && rhs.MapOfIntToString == nil) || (v.MapOfIntToString != nil && rhs.MapOfIntToString != nil && _Map_I32_String_Equals(v.MapOfIntToString, rhs.MapOfIntToString))) {
		return false
	}
	if !((v.MapOfStringToBool == nil && rhs.MapOfStringToBool == nil) || (v.MapOfStringToBool != nil && rhs.MapOfStringToBool != nil && _Map_String_Bool_Equals(v.MapOfStringToBool, rhs.MapOfStringToBool))) {
		return false
	}

	return true
}

type _List_Binary_Zapper [][]byte

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

type _List_I64_Zapper []int64

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

type _Set_Byte_mapType_Zapper map[int8]struct{}

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

type _Map_I32_String_Item_Zapper struct {
	Key   int32
	Value string
}

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

type _Map_I32_String_Zapper map[int32]string

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

type _Map_String_Bool_Zapper map[string]bool

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

// MarshalLogObject implements zapcore.ObjectMarshaler, enabling
// fast logging of PrimitiveContainers.
func (v *PrimitiveContainers) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
	if v == nil {
		return nil
	}
	if v.ListOfBinary != nil {
		err = multierr.Append(err, enc.AddArray("listOfBinary", (_List_Binary_Zapper)(v.ListOfBinary)))
	}
	if v.ListOfInts != nil {
		err = multierr.Append(err, enc.AddArray("listOfInts", (_List_I64_Zapper)(v.ListOfInts)))
	}
	if v.SetOfStrings != nil {
		err = multierr.Append(err, enc.AddArray("setOfStrings", (_Set_String_mapType_Zapper)(v.SetOfStrings)))
	}
	if v.SetOfBytes != nil {
		err = multierr.Append(err, enc.AddArray("setOfBytes", (_Set_Byte_mapType_Zapper)(v.SetOfBytes)))
	}
	if v.MapOfIntToString != nil {
		err = multierr.Append(err, enc.AddArray("mapOfIntToString", (_Map_I32_String_Zapper)(v.MapOfIntToString)))
	}
	if v.MapOfStringToBool != nil {
		err = multierr.Append(err, enc.AddObject("mapOfStringToBool", (_Map_String_Bool_Zapper)(v.MapOfStringToBool)))
	}
	return err
}

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

	return
}

// IsSetListOfBinary returns true if ListOfBinary is not nil.
func (v *PrimitiveContainers) IsSetListOfBinary() bool {
	return v != nil && v.ListOfBinary != nil
}

// GetListOfInts returns the value of ListOfInts if it is set or its
// zero value if it is unset.
func (v *PrimitiveContainers) GetListOfInts() (o []int64) {
	if v != nil && v.ListOfInts != nil {
		return v.ListOfInts
	}

	return
}

// IsSetListOfInts returns true if ListOfInts is not nil.
func (v *PrimitiveContainers) IsSetListOfInts() bool {
	return v != nil && v.ListOfInts != nil
}

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

	return
}

// IsSetSetOfStrings returns true if SetOfStrings is not nil.
func (v *PrimitiveContainers) IsSetSetOfStrings() bool {
	return v != nil && v.SetOfStrings != nil
}

// GetSetOfBytes returns the value of SetOfBytes if it is set or its
// zero value if it is unset.
func (v *PrimitiveContainers) GetSetOfBytes() (o map[int8]struct{}) {
	if v != nil && v.SetOfBytes != nil {
		return v.SetOfBytes
	}

	return
}

// IsSetSetOfBytes returns true if SetOfBytes is not nil.
func (v *PrimitiveContainers) IsSetSetOfBytes() bool {
	return v != nil && v.SetOfBytes != nil
}

// GetMapOfIntToString returns the value of MapOfIntToString if it is set or its
// zero value if it is unset.
func (v *PrimitiveContainers) GetMapOfIntToString() (o map[int32]string) {
	if v != nil && v.MapOfIntToString != nil {
		return v.MapOfIntToString
	}

	return
}

// IsSetMapOfIntToString returns true if MapOfIntToString is not nil.
func (v *PrimitiveContainers) IsSetMapOfIntToString() bool {
	return v != nil && v.MapOfIntToString != nil
}

// GetMapOfStringToBool returns the value of MapOfStringToBool if it is set or its
// zero value if it is unset.
func (v *PrimitiveContainers) GetMapOfStringToBool() (o map[string]bool) {
	if v != nil && v.MapOfStringToBool != nil {
		return v.MapOfStringToBool
	}

	return
}

// IsSetMapOfStringToBool returns true if MapOfStringToBool is not nil.
func (v *PrimitiveContainers) IsSetMapOfStringToBool() bool {
	return v != nil && v.MapOfStringToBool != nil
}

type PrimitiveContainersRequired struct {
	ListOfStrings      []string           `json:"listOfStrings,required"`
	SetOfInts          map[int32]struct{} `json:"setOfInts,required"`
	MapOfIntsToDoubles map[int64]float64  `json:"mapOfIntsToDoubles,required"`
}

type _Map_I64_Double_MapItemList map[int64]float64

func (m _Map_I64_Double_MapItemList) ForEach(f func(wire.MapItem) error) error {
	for k, v := range m {
		kw, err := wire.NewValueI64(k), error(nil)
		if err != nil {
			return err
		}

		vw, err := wire.NewValueDouble(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_I64_Double_MapItemList) Size() int {
	return len(m)
}

func (_Map_I64_Double_MapItemList) KeyType() wire.Type {
	return wire.TI64
}

func (_Map_I64_Double_MapItemList) ValueType() wire.Type {
	return wire.TDouble
}

func (_Map_I64_Double_MapItemList) Close() {}

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

	w, err = wire.NewValueList(_List_String_ValueList(v.ListOfStrings)), error(nil)
	if err != nil {
		return w, err
	}
	fields[i] = wire.Field{ID: 1, Value: w}
	i++
	if v.SetOfInts == nil {
		return w, errors.New("field SetOfInts of PrimitiveContainersRequired is required")
	}
	w, err = wire.NewValueSet(_Set_I32_mapType_ValueList(v.SetOfInts)), error(nil)
	if err != nil {
		return w, err
	}
	fields[i] = wire.Field{ID: 2, Value: w}
	i++
	if v.MapOfIntsToDoubles == nil {
		return w, errors.New("field MapOfIntsToDoubles of PrimitiveContainersRequired is required")
	}
	w, err = wire.NewValueMap(_Map_I64_Double_MapItemList(v.MapOfIntsToDoubles)), 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
}

func _Map_I64_Double_Read(m wire.MapItemList) (map[int64]float64, error) {
	if m.KeyType() != wire.TI64 {
		return nil, nil
	}

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

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

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

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

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

	listOfStringsIsSet := false
	setOfIntsIsSet := false
	mapOfIntsToDoublesIsSet := false

	for _, field := range w.GetStruct().Fields {
		switch field.ID {
		case 1:
			if field.Value.Type() == wire.TList {
				v.ListOfStrings, err = _List_String_Read(field.Value.GetList())
				if err != nil {
					return err
				}
				listOfStringsIsSet = true
			}
		case 2:
			if field.Value.Type() == wire.TSet {
				v.SetOfInts, err = _Set_I32_mapType_Read(field.Value.GetSet())
				if err != nil {
					return err
				}
				setOfIntsIsSet = true
			}
		case 3:
			if field.Value.Type() == wire.TMap {
				v.MapOfIntsToDoubles, err = _Map_I64_Double_Read(field.Value.GetMap())
				if err != nil {
					return err
				}
				mapOfIntsToDoublesIsSet = true
			}
		}
	}

	if !listOfStringsIsSet {
		return errors.New("field ListOfStrings of PrimitiveContainersRequired is required")
	}

	if !setOfIntsIsSet {
		return errors.New("field SetOfInts of PrimitiveContainersRequired is required")
	}

	if !mapOfIntsToDoublesIsSet {
		return errors.New("field MapOfIntsToDoubles of PrimitiveContainersRequired is required")
	}

	return nil
}

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

	var fields [3]string
	i := 0
	fields[i] = fmt.Sprintf("ListOfStrings: %v", v.ListOfStrings)
	i++
	fields[i] = fmt.Sprintf("SetOfInts: %v", v.SetOfInts)
	i++
	fields[i] = fmt.Sprintf("MapOfIntsToDoubles: %v", v.MapOfIntsToDoubles)
	i++

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

func _Map_I64_Double_Equals(lhs, rhs map[int64]float64) bool {
	if len(lhs) != len(rhs) {
		return false
	}

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

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

	return true
}

type _Map_I64_Double_Item_Zapper struct {
	Key   int64
	Value float64
}

// MarshalLogArray implements zapcore.ArrayMarshaler, enabling
// fast logging of _Map_I64_Double_Item_Zapper.
func (v _Map_I64_Double_Item_Zapper) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
	enc.AddInt64("key", v.Key)
	enc.AddFloat64("value", v.Value)
	return err
}

type _Map_I64_Double_Zapper map[int64]float64

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

// MarshalLogObject implements zapcore.ObjectMarshaler, enabling
// fast logging of PrimitiveContainersRequired.
func (v *PrimitiveContainersRequired) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
	if v == nil {
		return nil
	}
	err = multierr.Append(err, enc.AddArray("listOfStrings", (_List_String_Zapper)(v.ListOfStrings)))
	err = multierr.Append(err, enc.AddArray("setOfInts", (_Set_I32_mapType_Zapper)(v.SetOfInts)))
	err = multierr.Append(err, enc.AddArray("mapOfIntsToDoubles", (_Map_I64_Double_Zapper)(v.MapOfIntsToDoubles)))
	return err
}

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

// IsSetListOfStrings returns true if ListOfStrings is not nil.
func (v *PrimitiveContainersRequired) IsSetListOfStrings() bool {
	return v != nil && v.ListOfStrings != nil
}

// GetSetOfInts returns the value of SetOfInts if it is set or its
// zero value if it is unset.
func (v *PrimitiveContainersRequired) GetSetOfInts() (o map[int32]struct{}) {
	if v != nil {
		o = v.SetOfInts
	}
	return
}

// IsSetSetOfInts returns true if SetOfInts is not nil.
func (v *PrimitiveContainersRequired) IsSetSetOfInts() bool {
	return v != nil && v.SetOfInts != nil
}

// GetMapOfIntsToDoubles returns the value of MapOfIntsToDoubles if it is set or its
// zero value if it is unset.
func (v *PrimitiveContainersRequired) GetMapOfIntsToDoubles() (o map[int64]float64) {
	if v != nil {
		o = v.MapOfIntsToDoubles
	}
	return
}

// IsSetMapOfIntsToDoubles returns true if MapOfIntsToDoubles is not nil.
func (v *PrimitiveContainersRequired) IsSetMapOfIntsToDoubles() bool {
	return v != nil && v.MapOfIntsToDoubles != nil
}

// ThriftModule represents the IDL file used to generate this package.
var ThriftModule = &thriftreflect.ThriftModule{
	Name:     "containers",
	Package:  "go.uber.org/thriftrw/gen/internal/tests/containers",
	FilePath: "containers.thrift",
	SHA1:     "b4682204a85cf94d3742f09ef77d1a386b6c2ee7",
	Includes: []*thriftreflect.ThriftModule{
		enum_conflict.ThriftModule,
		enums.ThriftModule,
		typedefs.ThriftModule,
		uuid_conflict.ThriftModule,
	},
	Raw: rawIDL,
}

const rawIDL = "include \"./enums.thrift\"\ninclude \"./enum_conflict.thrift\"\ninclude \"./typedefs.thrift\"\ninclude \"./uuid_conflict.thrift\"\n\nstruct PrimitiveContainers {\n    1: optional list<binary> listOfBinary\n    2: optional list<i64> listOfInts\n    3: optional set<string> setOfStrings\n    4: optional set<byte> setOfBytes\n    5: optional map<i32, string> mapOfIntToString\n    6: optional map<string, bool> mapOfStringToBool\n}\n\nstruct PrimitiveContainersRequired {\n    1: required list<string> listOfStrings\n    2: required set<i32> setOfInts\n    3: required map<i64, double> mapOfIntsToDoubles\n}\n\nstruct EnumContainers {\n    1: optional list<enums.EnumDefault> listOfEnums\n    2: optional set<enums.EnumWithValues> setOfEnums\n    3: optional map<enums.EnumWithDuplicateValues, i32> mapOfEnums\n}\n\nstruct ContainersOfContainers {\n    1: optional list<list<i32>> listOfLists;\n    2: optional list<set<i32>> listOfSets;\n    3: optional list<map<i32, i32>> listOfMaps;\n\n    4: optional set<set<string>> setOfSets;\n    5: optional set<list<string>> setOfLists;\n    6: optional set<map<string, string>> setOfMaps;\n\n    7: optional map<map<string, i32>, i64> mapOfMapToInt;\n    8: optional map<list<i32>, set<i64>> mapOfListToSet;\n    9: optional map<set<i32>, list<double>> mapOfSetToListOfDouble;\n}\n\nstruct MapOfBinaryAndString {\n    1: optional map<binary, string> binaryToString;\n    2: optional map<string, binary> stringToBinary;\n}\n\nstruct ListOfRequiredPrimitives {\n    1: required list<string> listOfStrings\n}\n\nstruct ListOfOptionalPrimitives {\n    1: optional list<string> listOfStrings\n}\n\nstruct ListOfConflictingEnums {\n    1: required list<enum_conflict.RecordType> records\n    2: required list<enums.RecordType> otherRecords\n}\n\nstruct ListOfConflictingUUIDs {\n    1: required list<typedefs.UUID> uuids\n    2: required list<uuid_conflict.UUID> otherUUIDs\n}\n"