}
		if len(line) == 0 || line[0] != '"' {
			// Non-quoted string field
			i := bytes.IndexRune(line, r.Comma)
			field := line
			if i >= 0 {
				field = field[:i]
			} else {
				field = field[:len(field)-lengthNL(field)]
			}
			// Check to make sure a quote does not appear in field.
			if !r.LazyQuotes {
				if j := bytes.IndexByte(field, '"'); j >= 0 {
					col := pos.col + j

// BAD: we are not leaking param x, only x.p2
func field6(x *X) { // ERROR "leaking param content: x$"
	sink = x.p2
}

func field6a() {
	i := 0 // ERROR "moved to heap: i$"
	var x X
	// BAD: &i should not escape
	x.p1 = &i
	field6(&x)
}

func field7() {
	i := 0
	var y Y
	y.x.p1 = &i
	x := y.x
	var y1 Y
	y1.x = x
	_ = y1.x.p1
}

func field8() {
	i := 0 // ERROR "moved to heap: i$"
	var y Y

	A int
	B *int
	C string
}

func (S) M() {}

func field1(x S) int { // ERROR "x does not escape"
	v := reflect.ValueOf(x) // ERROR "x does not escape"
	return int(v.Field(0).Int())
}

func field2(x S) string { // ERROR "leaking param: x to result ~r0 level=0"
	v := reflect.ValueOf(x) // ERROR "x does not escape"
	return v.Field(2).String()
}

func numfield(x S) int { // ERROR "x does not escape"

				{Field: &schema.Field{Name: "FieldD"}},
			},
		},
		"uniq_field_e1_e2": {
			Name:  "uniq_field_e1_e2",
			Class: "UNIQUE",
			Fields: []schema.IndexOption{
				{Field: &schema.Field{Name: "FieldE1"}},
				{Field: &schema.Field{Name: "FieldE2"}},
			},
		},
		"idx_index_tests_field_f1": {
			Name:   "idx_index_tests_field_f1",
			Fields: []schema.IndexOption{{Field: &schema.Field{Name: "FieldF1"}}},

								"field1": {
									Type: "integer",
								},
								"field2": {
									Type: "integer",
								},
							},
							XValidations: apiextensions.ValidationRules{
								{
									Rule: "self.field1 < self.field2",
								},
							},
							Default: jsonPtr(map[string]interface{}{"field1": 1, "field2": 2}),
						},
					},
				},

	}
	// (pipe).Field1.Field2 has pipe as .Node, fields as .Field. Eval the pipeline, then the fields.
	pipe := s.evalArg(dot, nil, chain.Node)
	return s.evalFieldChain(dot, pipe, chain, chain.Field, args, final)
}

func (s *state) evalVariableNode(dot reflect.Value, variable *parse.VariableNode, args []parse.Node, final reflect.Value) reflect.Value {

	MethodField           Field = "Method"
	ProtocolField         Field = "Proto"
	AlpnField             Field = "Alpn"
	RequestHeaderField    Field = "RequestHeader"
	ResponseHeaderField   Field = "ResponseHeader"
	ClusterField          Field = "Cluster"
	IstioVersionField     Field = "IstioVersion"
	IPField               Field = "IP" // The Requester’s IP Address.
	LatencyField          Field = "Latency"

  metadata:
    name: test-list
    labels:
      pruneGroup: "true"
  someField: modifiedField
  newField: field3
- kind: Bar
  apiVersion: company.com/v1
  metadata:
    name: test-list
    labels:
      pruneGroup: "true"
  someField: modifiedField

// license that can be found in the LICENSE file.

package main

import (
	"strings"
	"testing"
)

func TestJSONFilterRewritePackage(t *testing.T) {
	const in = `{"Package":"abc"}
{"Field1":"1","Package":"abc","Field3":"3"}
{"Package":123}
{}
{"Package":"abc","Unexpected":[null,true,false,99999999999999999999]}
`
	want := strings.ReplaceAll(in, `"Package":"abc"`, `"Package":"abc:variant"`)

# Body - Fields

The same way you can declare additional validation and metadata in *path operation function* parameters with `Query`, `Path` and `Body`, you can declare validation and metadata inside of Pydantic models using Pydantic's `Field`.

## Import `Field`

First, you have to import it:

=== "Python 3.10+"

    ```Python hl_lines="4"
    {!> ../../../docs_src/body_fields/tutorial001_an_py310.py!}
    ```

=== "Python 3.9+"