Value(ctx context.Context, field *Field, dst reflect.Value, fieldValue interface{}) (interface{}, error)
}

// JSONSerializer json serializer
type JSONSerializer struct{}

// Scan implements serializer interface
func (JSONSerializer) Scan(ctx context.Context, field *Field, dst reflect.Value, dbValue interface{}) (err error) {
	fieldValue := reflect.New(field.FieldType)

	if dbValue != nil {
		var bytes []byte

	// misspelled     x.Foo   ==    FoO    type X has no field or method Foo, but does have field FoO
	// misspelled     x.Foo   ==    foo    type X has no field or method Foo, but does have field foo
	// misspelled     x.Foo   ==    foO    type X has no field or method Foo, but does have field foO
	//
	// misspelled     x.foo   ==    Foo    type X has no field or method foo, but does have field Foo

        "name": {
          "description": "Name field.",
          "type": "string"
        },
        "value": {
          "description": "Value field.",
          "type": "string"
        },
        "other": {
          "description": "Other field.",
          "type": "string"
        },
        "mergingList": {
          "description": "MergingList field.",
          "type": "array",
          "items": {

	// misspelled     x.Foo   ==    FoO    type X has no field or method Foo, but does have field FoO
	// misspelled     x.Foo   ==    foo    type X has no field or method Foo, but does have field foo
	// misspelled     x.Foo   ==    foO    type X has no field or method Foo, but does have field foO
	//
	// misspelled     x.foo   ==    Foo    type X has no field or method foo, but does have field Foo

func ValidatePodLogOptions(opts *v1.PodLogOptions) field.ErrorList {
	allErrs := field.ErrorList{}
	if opts.TailLines != nil && *opts.TailLines < 0 {
		allErrs = append(allErrs, field.Invalid(field.NewPath("tailLines"), *opts.TailLines, isNegativeErrorMsg))
	}
	if opts.LimitBytes != nil && *opts.LimitBytes < 1 {
		allErrs = append(allErrs, field.Invalid(field.NewPath("limitBytes"), *opts.LimitBytes, "must be greater than 0"))
	}

      #elseif ( $field.to && $field.multiplicity == "*" )
        List<${field.to}> oldVal = target.get${capField}();
        List<${field.to}> newVal = transform(oldVal, this::transform${field.to});
        return newVal != oldVal ? (builder != null ? builder : creator.get()).${field.name}(newVal) : builder;
      #elseif ( $field.type == "DOM" )
        XmlNode oldVal = target.get${capField}();

var _ = s.DoneChan                  // ERROR "s.DoneChan undefined .type http.Server has no field or method DoneChan.$|undefined field or method"
var _ = http.Server{tlsConfig: nil} // ERROR "cannot refer to unexported field tlsConfig in struct literal|unknown field .?tlsConfig.? in .?http.Server|unknown field"

	"k8s.io/apimachinery/pkg/util/validation/field"
)

// ValidateWebhookURL validates webhook's URL.
func ValidateWebhookURL(fldPath *field.Path, URL string, forceHttps bool) field.ErrorList {
	var allErrors field.ErrorList
	const form = "; desired format: https://host[/path]"
	if u, err := url.Parse(URL); err != nil {
		allErrors = append(allErrors, field.Required(fldPath, "url must be a valid URL: "+err.Error()+form))

					idx.Option = index.Option
				}

				idx.Fields = append(idx.Fields, index.Fields...)
				sort.Slice(idx.Fields, func(i, j int) bool {
					return idx.Fields[i].priority < idx.Fields[j].priority
				})

				indexes[index.Name] = idx
			}
		}
	}
	for _, index := range indexes {
		if index.Class == "UNIQUE" && len(index.Fields) == 1 {
			index.Fields[0].Field.UniqueIndex = index.Name
		}
	}
	return indexes
}

func ValidateRuntimeClassUpdate(new, old *node.RuntimeClass) field.ErrorList {
	allErrs := apivalidation.ValidateObjectMetaUpdate(&new.ObjectMeta, &old.ObjectMeta, field.NewPath("metadata"))

	allErrs = append(allErrs, apivalidation.ValidateImmutableField(new.Handler, old.Handler, field.NewPath("handler"))...)

	return allErrs
}

func validateOverhead(overhead *node.Overhead, fldPath *field.Path) field.ErrorList {