tr := NewReader(&buf)

	entries, err := fsys.ReadDir(".")
	if err != nil {
		t.Fatal(err)
	}

	var curfname string
	for _, entry := range entries {
		curfname = entry.Name()
		if entry.IsDir() {
			curfname += "/"
			continue
		}
		hdr, err := tr.Next()
		if err == io.EOF {
			break // End of archive
		}
		if err != nil {
			t.Fatal(err)

    return DBUser(name="John", surname="Doe", password_hash="secret")


@app.get("/response_model_list_of_model-no_annotation", response_model=List[User])
def response_model_list_of_model_no_annotation():
    return [
        DBUser(name="John", surname="Doe", password_hash="secret"),
        DBUser(name="Jane", surname="Does", password_hash="secret2"),
    ]

                    },
                    "type": "object",
                    "required": ["subname"],
                    "title": "SubItem",
                },
                "SubItem-Output": {
                    "properties": {
                        "subname": {"type": "string", "title": "Subname"},
                        "sub_description": {

				}

				if name == "" {
					subName := field.Name
					const key = "COMPOSITE"
					if composite, found := settings[key]; found {
						if len(composite) == 0 || composite == key {
							err = fmt.Errorf(
								"The composite tag of %s.%s cannot be empty",
								field.Schema.Name,
								field.Name)
							return
						}
						subName = composite
					}

        this.street = value;
    }

    public String getSurname() {
        checkSpecifiedProperty("surname");
        return convertEmptyToNull(surname);
    }

    public void setSurname(String value) {
        registerModifiedProperty("surname");
        this.surname = value;
    }

    public String getTelephoneNumber() {
        checkSpecifiedProperty("telephoneNumber");

        if (opLambda != null) {
            opLambda.callback(builder);
        }
    }

    public void setSurname_SpanTerm(String surname) {
        setSurname_SpanTerm("surname", null);
    }

    public void setSurname_SpanTerm(String surname, ConditionOptionCall<SpanTermQueryBuilder> opLambda) {
        SpanTermQueryBuilder builder = regSpanTermQ("surname", surname);

                "value": 80
              }
            ]
          },
          "unit": "none"
        },
        "overrides": [
          {
            "matcher": {
              "id": "byName",
              "options": "S3 Errors"
            },
            "properties": [
              {
                "id": "color",
                "value": {
                  "fixedColor": "light-red",

                "value": 80
              }
            ]
          },
          "unit": "bytes"
        },
        "overrides": [
          {
            "matcher": {
              "id": "byName",
              "options": "Replication Errors"
            },
            "properties": [
              {
                "id": "color",
                "value": {
                  "fixedColor": "light-red",

	// except in the definition (handled at end of function).
	refName := make(map[*ast.Expr]*Name)
	for _, r := range f.Ref {
		refName[r.Expr] = r.Name
	}
	for _, d := range f.AST.Decls {
		d, ok := d.(*ast.GenDecl)
		if !ok || d.Tok != token.TYPE {
			continue
		}
		for _, s := range d.Specs {
			s := s.(*ast.TypeSpec)
			n := refName[&s.Type]
			if n != nil && n.Mangle != "" {
				override[n.Mangle] = s.Name.Name

If the argument to [FileInfoHeader] implements the new [FileInfoNames]
interface, then the interface methods will be used to set the Uname/Gname
of the file header. This allows applications to override the system-dependent