func (b *FugaJSONBuilder) AddByJSONNames(names ...string) *FugaJSONBuilder {
	for _, name := range names {
		info := b._jsonPropertyMap[name]
		if info == nil {
			continue
		}
		b._properties[info.fieldName] = info
	}
	return b
}
AddByJSONNames add properties to FugaJSONBuilder by JSON property name. if name is not in the builder, it will ignore.
package j
import (
	"encoding/json"
)
type FooJSON struct {
	Tmp       *Temp `json:"tmp,omitempty"`
	Bar       `json:",omitempty"`
	*Buzz     `json:",omitempty"`
	HogeJSON  `json:",omitempty"`
	*FugaJSON `json:",omitempty"`
}
type FooJSONList []*FooJSON
type FooPropertyEncoder func(src *Foo, dest *FooJSON) error
type FooPropertyDecoder func(src *FooJSON, dest *Foo) error
type FooPropertyInfo struct {
	fieldName string
	jsonName  string
	Encoder   FooPropertyEncoder
	Decoder   FooPropertyDecoder
}
func (info *FooPropertyInfo) FieldName() string {
	return info.fieldName
}
func (info *FooPropertyInfo) JSONName() string {
	return info.jsonName
}
type FooJSONBuilder struct {
	_properties        map[string]*FooPropertyInfo
	_jsonPropertyMap   map[string]*FooPropertyInfo
	_structPropertyMap map[string]*FooPropertyInfo
	Tmp                *FooPropertyInfo
	Bar                *FooPropertyInfo
	Buzz               *FooPropertyInfo
	Hoge               *FooPropertyInfo
	Fuga               *FooPropertyInfo
}
func NewFooJSONBuilder() *FooJSONBuilder {
	jb := &FooJSONBuilder{
		_properties:        map[string]*FooPropertyInfo{},
		_jsonPropertyMap:   map[string]*FooPropertyInfo{},
		_structPropertyMap: map[string]*FooPropertyInfo{},
		Tmp: &FooPropertyInfo{
			fieldName: "Tmp",
			jsonName:  "tmp",
			Encoder: func(src *Foo, dest *FooJSON) error {
				if src == nil {
					return nil
				}
				dest.Tmp = src.Tmp
				return nil
			},
			Decoder: func(src *FooJSON, dest *Foo) error {
				if src == nil {
					return nil
				}
				dest.Tmp = src.Tmp
				return nil
			},
		},
		Bar: &FooPropertyInfo{
			fieldName: "Bar",
			jsonName:  "",
			Encoder: func(src *Foo, dest *FooJSON) error {
				if src == nil {
					return nil
				}
				dest.Bar = src.Bar
				return nil
			},
			Decoder: func(src *FooJSON, dest *Foo) error {
				if src == nil {
					return nil
				}
				dest.Bar = src.Bar
				return nil
			},
		},
		Buzz: &FooPropertyInfo{
			fieldName: "Buzz",
			jsonName:  "",
			Encoder: func(src *Foo, dest *FooJSON) error {
				if src == nil {
					return nil
				}
				dest.Buzz = src.Buzz
				return nil
			},
			Decoder: func(src *FooJSON, dest *Foo) error {
				if src == nil {
					return nil
				}
				dest.Buzz = src.Buzz
				return nil
			},
		},
		Hoge: &FooPropertyInfo{
			fieldName: "Hoge",
			jsonName:  "",
			Encoder: func(src *Foo, dest *FooJSON) error {
				if src == nil {
					return nil
				}
				d, err := NewHogeJSONBuilder().AddAll().Convert(&src.Hoge)
				if err != nil {
					return err
				}
				dest.HogeJSON = *d
				return nil
			},
			Decoder: func(src *FooJSON, dest *Foo) error {
				if src == nil {
					return nil
				}
				d, err := src.HogeJSON.Convert()
				if err != nil {
					return err
				}
				dest.Hoge = *d
				return nil
			},
		},
		Fuga: &FooPropertyInfo{
			fieldName: "Fuga",
			jsonName:  "",
			Encoder: func(src *Foo, dest *FooJSON) error {
				if src == nil {
					return nil
				} else if src.Fuga == nil {
					return nil
				}
				d, err := NewFugaJSONBuilder().AddAll().Convert(src.Fuga)
				if err != nil {
					return err
				}
				dest.FugaJSON = d
				return nil
			},
			Decoder: func(src *FooJSON, dest *Foo) error {
				if src == nil {
					return nil
				} else if src.FugaJSON == nil {
					return nil
				}
				d, err := src.FugaJSON.Convert()
				if err != nil {
					return err
				}
				dest.Fuga = d
				return nil
			},
		},
	}
	jb._structPropertyMap["Tmp"] = jb.Tmp
	jb._jsonPropertyMap["tmp"] = jb.Tmp
	jb._structPropertyMap["Bar"] = jb.Bar
	jb._jsonPropertyMap[""] = jb.Bar
	jb._structPropertyMap["Buzz"] = jb.Buzz
	jb._jsonPropertyMap[""] = jb.Buzz
	jb._structPropertyMap["Hoge"] = jb.Hoge
	jb._jsonPropertyMap[""] = jb.Hoge
	jb._structPropertyMap["Fuga"] = jb.Fuga
	jb._jsonPropertyMap[""] = jb.Fuga
	return jb
}
func (b *FooJSONBuilder) Properties() []*FooPropertyInfo {
	return []*FooPropertyInfo{
		b.Tmp,
		b.Bar,
		b.Buzz,
		b.Hoge,
		b.Fuga,
	}
}
func (b *FooJSONBuilder) AddAll() *FooJSONBuilder {
	b._properties["Tmp"] = b.Tmp
	b._properties["Bar"] = b.Bar
	b._properties["Buzz"] = b.Buzz
	b._properties["Hoge"] = b.Hoge
	b._properties["Fuga"] = b.Fuga
	return b
}
func (b *FooJSONBuilder) Add(info *FooPropertyInfo) *FooJSONBuilder {
	b._properties[info.fieldName] = info
	return b
}
func (b *FooJSONBuilder) AddByJSONNames(names ...string) *FooJSONBuilder {
	for _, name := range names {
		info := b._jsonPropertyMap[name]
		if info == nil {
			continue
		}
		b._properties[info.fieldName] = info
	}
	return b
}
func (b *FooJSONBuilder) AddByNames(names ...string) *FooJSONBuilder {
	for _, name := range names {
		info := b._structPropertyMap[name]
		if info == nil {
			continue
		}
		b._properties[info.fieldName] = info
	}
	return b
}
func (b *FooJSONBuilder) Remove(info *FooPropertyInfo) *FooJSONBuilder {
	delete(b._properties, info.fieldName)
	return b
}
func (b *FooJSONBuilder) RemoveByJSONNames(names ...string) *FooJSONBuilder {
	for _, name := range names {
		info := b._jsonPropertyMap[name]
		if info == nil {
			continue
		}
		delete(b._properties, info.fieldName)
	}
	return b
}
func (b *FooJSONBuilder) RemoveByNames(names ...string) *FooJSONBuilder {
	for _, name := range names {
		info := b._structPropertyMap[name]
		if info == nil {
			continue
		}
		delete(b._properties, info.fieldName)
	}
	return b
}
func (b *FooJSONBuilder) Convert(orig *Foo) (*FooJSON, error) {
	if orig == nil {
		return nil, nil
	}
	ret := &FooJSON{}
	for _, info := range b._properties {
		if err := info.Encoder(orig, ret); err != nil {
			return nil, err
		}
	}
	return ret, nil
}
func (b *FooJSONBuilder) ConvertList(orig []*Foo) (FooJSONList, error) {
	if orig == nil {
		return nil, nil
	}
	list := make(FooJSONList, len(orig))
	for idx, or := range orig {
		json, err := b.Convert(or)
		if err != nil {
			return nil, err
		}
		list[idx] = json
	}
	return list, nil
}
func (orig *FooJSON) Convert() (*Foo, error) {
	ret := &Foo{}
	b := NewFooJSONBuilder().AddAll()
	for _, info := range b._properties {
		if err := info.Decoder(orig, ret); err != nil {
			return nil, err
		}
	}
	return ret, nil
}
func (jsonList FooJSONList) Convert() ([]*Foo, error) {
	orig := ([]*FooJSON)(jsonList)
	list := make([]*Foo, len(orig))
	for idx, or := range orig {
		obj, err := or.Convert()
		if err != nil {
			return nil, err
		}
		list[idx] = obj
	}
	return list, nil
}
func (b *FooJSONBuilder) Marshal(orig *Foo) ([]byte, error) {
	ret, err := b.Convert(orig)
	if err != nil {
		return nil, err
	}
	return json.Marshal(ret)
}
type HogeJSON struct {
	Hoge1 string `json:"hoge1,omitempty"`
}
type HogeJSONList []*HogeJSON
type HogePropertyEncoder func(src *Hoge, dest *HogeJSON) error
type HogePropertyDecoder func(src *HogeJSON, dest *Hoge) error
type HogePropertyInfo struct {
	fieldName string
	jsonName  string
	Encoder   HogePropertyEncoder
	Decoder   HogePropertyDecoder
}
func (info *HogePropertyInfo) FieldName() string {
	return info.fieldName
}
func (info *HogePropertyInfo) JSONName() string {
	return info.jsonName
}
type HogeJSONBuilder struct {
	_properties        map[string]*HogePropertyInfo
	_jsonPropertyMap   map[string]*HogePropertyInfo
	_structPropertyMap map[string]*HogePropertyInfo
	Hoge1              *HogePropertyInfo
}
func NewHogeJSONBuilder() *HogeJSONBuilder {
	jb := &HogeJSONBuilder{
		_properties:        map[string]*HogePropertyInfo{},
		_jsonPropertyMap:   map[string]*HogePropertyInfo{},
		_structPropertyMap: map[string]*HogePropertyInfo{},
		Hoge1: &HogePropertyInfo{
			fieldName: "Hoge1",
			jsonName:  "hoge1",
			Encoder: func(src *Hoge, dest *HogeJSON) error {
				if src == nil {
					return nil
				}
				dest.Hoge1 = src.Hoge1
				return nil
			},
			Decoder: func(src *HogeJSON, dest *Hoge) error {
				if src == nil {
					return nil
				}
				dest.Hoge1 = src.Hoge1
				return nil
			},
		},
	}
	jb._structPropertyMap["Hoge1"] = jb.Hoge1
	jb._jsonPropertyMap["hoge1"] = jb.Hoge1
	return jb
}
func (b *HogeJSONBuilder) Properties() []*HogePropertyInfo {
	return []*HogePropertyInfo{
		b.Hoge1,
	}
}
func (b *HogeJSONBuilder) AddAll() *HogeJSONBuilder {
	b._properties["Hoge1"] = b.Hoge1
	return b
}
func (b *HogeJSONBuilder) Add(info *HogePropertyInfo) *HogeJSONBuilder {
	b._properties[info.fieldName] = info
	return b
}
func (b *HogeJSONBuilder) AddByJSONNames(names ...string) *HogeJSONBuilder {
	for _, name := range names {
		info := b._jsonPropertyMap[name]
		if info == nil {
			continue
		}
		b._properties[info.fieldName] = info
	}
	return b
}
func (b *HogeJSONBuilder) AddByNames(names ...string) *HogeJSONBuilder {
	for _, name := range names {
		info := b._structPropertyMap[name]
		if info == nil {
			continue
		}
		b._properties[info.fieldName] = info
	}
	return b
}
func (b *HogeJSONBuilder) Remove(info *HogePropertyInfo) *HogeJSONBuilder {
	delete(b._properties, info.fieldName)
	return b
}
func (b *HogeJSONBuilder) RemoveByJSONNames(names ...string) *HogeJSONBuilder {
	for _, name := range names {
		info := b._jsonPropertyMap[name]
		if info == nil {
			continue
		}
		delete(b._properties, info.fieldName)
	}
	return b
}
func (b *HogeJSONBuilder) RemoveByNames(names ...string) *HogeJSONBuilder {
	for _, name := range names {
		info := b._structPropertyMap[name]
		if info == nil {
			continue
		}
		delete(b._properties, info.fieldName)
	}
	return b
}
func (b *HogeJSONBuilder) Convert(orig *Hoge) (*HogeJSON, error) {
	if orig == nil {
		return nil, nil
	}
	ret := &HogeJSON{}
	for _, info := range b._properties {
		if err := info.Encoder(orig, ret); err != nil {
			return nil, err
		}
	}
	return ret, nil
}
func (b *HogeJSONBuilder) ConvertList(orig []*Hoge) (HogeJSONList, error) {
	if orig == nil {
		return nil, nil
	}
	list := make(HogeJSONList, len(orig))
	for idx, or := range orig {
		json, err := b.Convert(or)
		if err != nil {
			return nil, err
		}
		list[idx] = json
	}
	return list, nil
}
func (orig *HogeJSON) Convert() (*Hoge, error) {
	ret := &Hoge{}
	b := NewHogeJSONBuilder().AddAll()
	for _, info := range b._properties {
		if err := info.Decoder(orig, ret); err != nil {
			return nil, err
		}
	}
	return ret, nil
}
func (jsonList HogeJSONList) Convert() ([]*Hoge, error) {
	orig := ([]*HogeJSON)(jsonList)
	list := make([]*Hoge, len(orig))
	for idx, or := range orig {
		obj, err := or.Convert()
		if err != nil {
			return nil, err
		}
		list[idx] = obj
	}
	return list, nil
}
func (b *HogeJSONBuilder) Marshal(orig *Hoge) ([]byte, error) {
	ret, err := b.Convert(orig)
	if err != nil {
		return nil, err
	}
	return json.Marshal(ret)
}
type FugaJSON struct {
	Fuga1 string `json:"fuga1,omitempty"`
}
type FugaJSONList []*FugaJSON
type FugaPropertyEncoder func(src *Fuga, dest *FugaJSON) error
type FugaPropertyDecoder func(src *FugaJSON, dest *Fuga) error
type FugaPropertyInfo struct {
	fieldName string
	jsonName  string
	Encoder   FugaPropertyEncoder
	Decoder   FugaPropertyDecoder
}
func (info *FugaPropertyInfo) FieldName() string {
	return info.fieldName
}
func (info *FugaPropertyInfo) JSONName() string {
	return info.jsonName
}
type FugaJSONBuilder struct {
	_properties        map[string]*FugaPropertyInfo
	_jsonPropertyMap   map[string]*FugaPropertyInfo
	_structPropertyMap map[string]*FugaPropertyInfo
	Fuga1              *FugaPropertyInfo
}
func NewFugaJSONBuilder() *FugaJSONBuilder {
	jb := &FugaJSONBuilder{
		_properties:        map[string]*FugaPropertyInfo{},
		_jsonPropertyMap:   map[string]*FugaPropertyInfo{},
		_structPropertyMap: map[string]*FugaPropertyInfo{},
		Fuga1: &FugaPropertyInfo{
			fieldName: "Fuga1",
			jsonName:  "fuga1",
			Encoder: func(src *Fuga, dest *FugaJSON) error {
				if src == nil {
					return nil
				}
				dest.Fuga1 = src.Fuga1
				return nil
			},
			Decoder: func(src *FugaJSON, dest *Fuga) error {
				if src == nil {
					return nil
				}
				dest.Fuga1 = src.Fuga1
				return nil
			},
		},
	}
	jb._structPropertyMap["Fuga1"] = jb.Fuga1
	jb._jsonPropertyMap["fuga1"] = jb.Fuga1
	return jb
}
func (b *FugaJSONBuilder) Properties() []*FugaPropertyInfo {
	return []*FugaPropertyInfo{
		b.Fuga1,
	}
}
func (b *FugaJSONBuilder) AddAll() *FugaJSONBuilder {
	b._properties["Fuga1"] = b.Fuga1
	return b
}
func (b *FugaJSONBuilder) Add(info *FugaPropertyInfo) *FugaJSONBuilder {
	b._properties[info.fieldName] = info
	return b
}