get() = withValidityAssertion { field }

    /**
     * The class reference type, e.g. `Array<String>` for the `Array<String>::class` literal.
     */
    public val type: KaType = type
        get() = withValidityAssertion { field }

    override val sourcePsi: KtElement? = sourcePsi
        get() = withValidityAssertion { field }
}

    // --------------------------/
    // - Class/Member Variables -/
    // --------------------------/

    /**
     * Field lifecycles.
     */
    private java.util.List<Lifecycle> lifecycles;

    /**
     * Field modelEncoding.
     */
    private String modelEncoding = "UTF-8";

    // -----------/
    // - Methods -/
    // -----------/

    /**

	})
	return err
}

func iterSimple(yield func(int) bool) {
	for range 3 {
		if !yield(5) {
			return
		}
	}
}

func iterNested(yield func(int) bool) {
	next, stop := iter.Pull(iterSimple)
	for {
		v, ok := next()
		if ok {
			if !yield(v) {
				stop()
			}
		} else {
			return
		}
	}
}

func iterCallback(yield func(int) bool) {
	for range 3 {

		if len(errs) != 0 {
			t.Logf("errors returned: %v", errs)
		}
		if len(errs) != 0 && typeName == "object" {
			t.Errorf("unexpected forbidden field validation errors for: %#v", s)
		}
		if len(errs) == 0 && typeName != "object" {
			t.Errorf("expected forbidden field validation errors for: %#v", s)
		}
	}

	// check that anything other than name and generateName of ObjectMeta in metadata properties is forbidden

	}
}

type validationMatch struct {
	path      *field.Path
	errorType field.ErrorType
}

func required(path ...string) validationMatch {
	return validationMatch{path: field.NewPath(path[0], path[1:]...), errorType: field.ErrorTypeRequired}
}
func invalid(path ...string) validationMatch {
	return validationMatch{path: field.NewPath(path[0], path[1:]...), errorType: field.ErrorTypeInvalid}
}

		for i := 0; i < tp.NumField(); i++ {
			field := tp.Field(i)
			paths.Insert(sets.List(allPrimitiveFieldPaths(t, skipRecurseList, field.Type, path.Child(field.Name)))...)
		}
	case reflect.Map, reflect.Slice:
		paths.Insert(sets.List(allPrimitiveFieldPaths(t, skipRecurseList, tp.Elem(), path.Key("*")))...)
	case reflect.Interface:
		t.Fatalf("unexpected interface{} field %s", path.String())
	default:

	return func(yield func(K, V) bool) {
		for k, v := range m {
			if !yield(k, v) {
				return
			}
		}
	}
}

// Keys returns an iterator over keys in m.
// The iteration order is not specified and is not guaranteed
// to be the same from one call to the next.
func Keys[Map ~map[K]V, K comparable, V any](m Map) iter.Seq[K] {
	return func(yield func(K) bool) {
		for k := range m {

	"managedBy":               "ManagedBy field indicates the controller that manages a Job. The k8s Job controller reconciles jobs which don't have this field at all or the field value is the reserved string `kubernetes.io/job-controller`, but skips reconciling Jobs with a custom value for this field. The value must be a valid domain-prefixed path (e.g....

import org.apache.maven.api.annotations.Experimental;

/**
 * Indicates that a given field will be injected with the result of
 * a dependency collection or resolution request. Whether a collection
 * or resolution request is performed is controlled by the {@link #pathScope()}
 * field, the injected field type and the {@link #requestType()}.
 * <p>
 * If the {@code requestType} is not set explicitly, it will be inferred

	return t.goString(0, "")
}

func (t *Typed) goString(indent int, field string) string {
	return fmt.Sprintf("%*s%sTyped:\n%s\n%s", indent, "", field,
		t.Name.goString(indent+2, "Name: "),
		t.Type.goString(indent+2, "Type: "))
}

// Qualified is a name in a scope.
type Qualified struct {
	Scope AST
	Name  AST

	// The LocalName field is true if this is parsed as a