// NewPeopleJSONBuilder make new PeopleJSONBuilder.
482496
func NewPeopleJSONBuilder() *PeopleJSONBuilder {
	jb := &PeopleJSONBuilder{
		_properties:        map[string]*PeoplePropertyInfo{},
		_jsonPropertyMap:   map[string]*PeoplePropertyInfo{},
		_structPropertyMap: map[string]*PeoplePropertyInfo{},
		ShowPrivateInfo: &PeoplePropertyInfo{
			fieldName: "ShowPrivateInfo",
			jsonName:  "showPrivateInfo",
			Encoder: func(src *People, dest *PeopleJSON) error {
				if src == nil {
					return nil
				}
				dest.ShowPrivateInfo = src.ShowPrivateInfo
				return nil
			},
			Decoder: func(src *PeopleJSON, dest *People) error {
				if src == nil {
					return nil
				}
				dest.ShowPrivateInfo = src.ShowPrivateInfo
				return nil
			},
		},
		List: &PeoplePropertyInfo{
			fieldName: "List",
			jsonName:  "list",
			Encoder: func(src *People, dest *PeopleJSON) error {
				if src == nil {
					return nil
				}
				list, err := NewPersonJSONBuilder().AddAll().ConvertList(src.List)
				if err != nil {
					return err
				}
				dest.List = ([]*PersonJSON)(list)
				return nil
			},
			Decoder: func(src *PeopleJSON, dest *People) error {
				if src == nil {
					return nil
				}
				list := make([]*Person, len(src.List))
				for idx, obj := range src.List {
					if obj == nil {
						continue
					}
					d, err := obj.Convert()
					if err != nil {
						return err
					}
					list[idx] = d
				}
				dest.List = list
				return nil
			},
		},
	}
	jb._structPropertyMap["ShowPrivateInfo"] = jb.ShowPrivateInfo
	jb._jsonPropertyMap["showPrivateInfo"] = jb.ShowPrivateInfo
	jb._structPropertyMap["List"] = jb.List
	jb._jsonPropertyMap["list"] = jb.List
	return jb
}
714523
func NewBuilder(client K8sClient, schema string) resolver.Builder {
	return &kubeBuilder{
		k8sClient: client,
		schema:    schema,
	}
}
772285
func (j *GoGoJSONPb) NewEncoder(w io.Writer) Encoder {
	return EncoderFunc(func(v interface{}) error { return j.marshalTo(w, v) })
}
1145537
func (orig *PeopleJSON) Convert() (*People, error) {
	ret := &People{}

	b := NewPeopleJSONBuilder().AddAll()
	for _, info := range b._properties {
		if err := info.Decoder(orig, ret); err != nil {
			return nil, err
		}
	}

	return ret, nil
}
643999
func NewGroupMembersSelector(Group *GroupSelector, Users *UsersSelectorArg) *GroupMembersSelector {
	s := new(GroupMembersSelector)
	s.Group = Group
	s.Users = Users
	return s
}
997516
func NewRepoBuilder(gun data.GUN, cs signed.CryptoService, trustpin trustpinning.TrustPinConfig) RepoBuilder {
	return NewBuilderFromRepo(gun, NewRepo(cs), trustpin)
}
749415
func NewPersonalization() *Personalization {
	return &Personalization{
		To:                  make([]*Email, 0),
		CC:                  make([]*Email, 0),
		BCC:                 make([]*Email, 0),
		Headers:             make(map[string]string),
		Substitutions:       make(map[string]string),
		CustomArgs:          make(map[string]string),
		DynamicTemplateData: make(map[string]interface{}),
		Categories:          make([]string, 0),
	}
}
1080412
func (p *PersonaIDType) UnmarshalJSON(data []byte) error {
	var s string
	if err := json.Unmarshal(data, &s); err != nil {
		return err
	}
	*p = ParsePersonaIDType(s)
	return nil
}
560013
func (s *Style) Builder() *StyleBuilder {
	return &StyleBuilder{
		name:    s.Name,
		entries: map[TokenType]string{},
		parent:  s,
	}
}
562836
func NewHumanReadablePrinter(noHeaders, withNamespace bool, wide bool, showAll bool, showLabels bool, absoluteTimestamps bool, columnLabels []string) *HumanReadablePrinter {
	printer := &HumanReadablePrinter{
		handlerMap: make(map[reflect.Type]*handlerEntry),
		options: PrintOptions{
			NoHeaders:          noHeaders,
			WithNamespace:      withNamespace,
			Wide:               wide,
			ShowAll:            showAll,
			ShowLabels:         showLabels,
			AbsoluteTimestamps: absoluteTimestamps,
			ColumnLabels:       columnLabels,
		},
	}
	printer.addDefaultHandlers()
	return printer
}
510108
func (mr *MockBuilderFactoryMockRecorder) NewBuilder(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewBuilder", reflect.TypeOf((*MockBuilderFactory)(nil).NewBuilder), arg0, arg1)
}
1117132
func NewHumanReadablePrinter(noHeaders, withNamespace bool, wide bool, showAll bool, columnLabels []string) *HumanReadablePrinter {
	printer := &HumanReadablePrinter{
		handlerMap:    make(map[reflect.Type]*handlerEntry),
		noHeaders:     noHeaders,
		withNamespace: withNamespace,
		wide:          wide,
		showAll:       showAll,
		columnLabels:  columnLabels,
	}
	printer.addDefaultHandlers()
	return printer
}
857238
func (j *JSONPb) NewDecoder(r io.Reader) Decoder {
	d := json.NewDecoder(r)
	return DecoderWrapper{Decoder: d}
}
159758
func (m *MockBuilderFactory) NewBuilder(arg0 blobstore.Blobstore, arg1 agentclient.AgentClient) state.Builder {
	ret := m.ctrl.Call(m, "NewBuilder", arg0, arg1)
	ret0, _ := ret[0].(state.Builder)
	return ret0
}
1004395
func NewNKeeper(n int) *NKeeper {
	k := NKeeper{make(Heap, 1, n)}
	k.Heap[0].Dist = inf
	return &k
}
475493
func (b *PersonJSONBuilder) Add(info *PersonPropertyInfo) *PersonJSONBuilder {
	b._properties[info.fieldName] = info
	return b
}
93633
func NewInnerJSONBuilder() *InnerJSONBuilder {
	jb := &InnerJSONBuilder{
		_properties:        map[string]*InnerPropertyInfo{},
		_jsonPropertyMap:   map[string]*InnerPropertyInfo{},
		_structPropertyMap: map[string]*InnerPropertyInfo{},
		A: &InnerPropertyInfo{
			fieldName: "A",
			jsonName:  "a",
			Encoder: func(src *Inner, dest *InnerJSON) error {
				if src == nil {
					return nil
				}
				dest.A = src.A
				return nil
			},
			Decoder: func(src *InnerJSON, dest *Inner) error {
				if src == nil {
					return nil
				}
				dest.A = src.A
				return nil
			},
		},
	}
	jb._structPropertyMap["A"] = jb.A
	jb._jsonPropertyMap["a"] = jb.A
	return jb
}