if (isExcludeSearchword(words[i], fields != null && fields.length > 0 ? fields[0] : "", langs, analyzer)) {
                    continue;
                }

                final String word = normalizer.normalize(words[i], fields != null && fields.length > 0 ? fields[0] : "", langs);
                final List<String> l = readingConverter.convert(word, fields != null && fields.length > 0 ? fields[0] : "", langs);

		if fieldStruct := modelType.Field(i); ast.IsExported(fieldStruct.Name) {
			if field := schema.ParseField(fieldStruct); field.EmbeddedSchema != nil {
				schema.Fields = append(schema.Fields, field.EmbeddedSchema.Fields...)
			} else {
				schema.Fields = append(schema.Fields, field)
			}
		}
	}

	for _, field := range schema.Fields {
		if field.DBName == "" && field.DataType != "" {

index.field.config_id=config_id
index.field.expires=expires
index.field.url=url
index.field.doc_id=doc_id
index.field.id=_id
index.field.version=_version
index.field.seq_no=_seq_no
index.field.primary_term=_primary_term
index.field.lang=lang
index.field.has_cache=has_cache
index.field.last_modified=last_modified
index.field.anchor=anchor
index.field.segment=segment
index.field.role=role
index.field.boost=boost

      <name>Metadata</name>
      <version>1.0.0+</version>
      <fields>
        <field xml.attribute="true" xml.tagName="modelVersion">
          <name>modelVersion</name>
          <version>1.1.0+</version>
          <type>String</type>
          <description>The version of the underlying metadata model.</description>
        </field>
        <field>
          <name>groupId</name>
          <version>1.0.0+</version>

    # fields but it's the same one, so count them by name
    body_param_names_set = {field.name for field in fields}
    # A top level field has to be a single field, not multiple
    if len(body_param_names_set) > 1:
        return True
    first_field = fields[0]
    # If it explicitly specifies it is embedded, it has to be embedded

// GetIdentityFieldValuesMapFromValues get identity map from fields
func GetIdentityFieldValuesMapFromValues(ctx context.Context, values []interface{}, fields []*Field) (map[string][]reflect.Value, [][]interface{}) {
	resultsMap := map[string][]reflect.Value{}
	results := [][]interface{}{}

	for _, v := range values {
		rm, rs := GetIdentityFieldValuesMap(ctx, reflect.Indirect(reflect.ValueOf(v)), fields)
		for k, v := range rm {

                if (q instanceof BooleanQuery) {
                    queryList.addAll(getTermQueryList(q, fields));
                } else if (q instanceof final TermQuery termQuery) {
                    for (final String field : fields) {
                        if (field.equals(termQuery.getTerm().field())) {
                            queryList.add(termQuery);
                        }
                    }

      <description>Dependency collection or resolution injection.</description>
      <fields>
        <field>
          <name>field</name>
          <required>false</required>
          <version>2.0.0+</version>
          <type>String</type>
          <description>the name of the field to be injected</description>
        </field>
        <field>
          <name>pathScope</name>
          <required>false</required>

    public void addField(final String key, final Object value) {
        fields.put(key, value);
    }

    public String getLogMessage() {
        return getUrl();
    }

    @Override
    public Map<String, Object> toSource() {
        final Map<String, Object> sourceMap = super.toSource();
        if (fields != null) {
            sourceMap.putAll(fields);
        }
        return sourceMap;
    }

    @Override

        if (value instanceof final LocalDateTime ldt) {
            final ZonedDateTime zdt = ZonedDateTime.of(ldt, ZoneId.systemDefault());
            super.addFieldToSource(sourceMap, field, DateTimeFormatter.ISO_INSTANT.format(zdt));
        } else {
            super.addFieldToSource(sourceMap, field, value);
        }
    }

    @Override