Not possible to deserialize/create a score function of type "weight"

[brentam]

What is the bug?

not possible to build/deserialize a score function of type "weight".
Therefore, we are not able to construct queries that contains the "weight" score function type.

This search query is a correct query:

{
  "query": {
    "function_score": {
      "query": { "match_all": {} },
      "boost": "5",
      "functions": [
        {
          "filter": { "match": { "test": "bar" } },
          "random_score": {},
          "weight": 23
        },
        {
          "filter": { "match": { "test": "cat" } },
          "weight": 42
        }
      ],
      "max_boost": 42,
      "score_mode": "max",
      "boost_mode": "multiply",
      "min_score": 42
    }
  }
}

Notice the function array, the second one is a correct function type "weight" as per the documentation.

        {
          "filter": { "match": { "test": "cat" } },
          "weight": 42
        }

Unfortunatelly, there is no way to deserialize or build that score function using the api.
The problem seems in the FunctionScore.Kind enum

    public enum Kind implements JsonEnum {
        Exp("exp"),

        Gauss("gauss"),

        Linear("linear"),

        FieldValueFactor("field_value_factor"),

        RandomScore("random_score"),

        ScriptScore("script_score"),

        ;

        private final String jsonValue;

        Kind(String jsonValue) {
            this.jsonValue = jsonValue;
        }

        public String jsonValue() {
            return this.jsonValue;
        }

    }

These are hardcoded values with the json field expected by all the types.
The issue is that she "weight" function is characterized by the abscense of any of the values above,

How can one reproduce the bug?

Look at the test below:
the willThrowException test should not throw any exception

public class FunctionScoreKindTest extends Assert {

private final JsonpMapper mapper = new JsonbJsonpMapper();

    @Test
    public void willDeserialize() {

        String str = "{\n" +
                "          \"filter\": { \"match\": { \"test\": \"bar\" } },\n" +
                "          \"random_score\": {},\n" +
                "          \"weight\": 23\n" +
                "        }";

        JsonParser parser = mapper.jsonProvider().createParser(new StringReader(str));
        FunctionScore functionScore = FunctionScore._DESERIALIZER.deserialize(parser, mapper);
        assertTrue(functionScore.isRandomScore());
    }

    @Test
    public void willThrowException() {
        String str = " {\n" +
                "          \"filter\": { \"match\": { \"test\": \"cat\" } },\n" +
                "          \"weight\": 42\n" +
                "        }";

        JsonParser parser = mapper.jsonProvider().createParser(new StringReader(str));

        MissingRequiredPropertyException exception=assertThrows(MissingRequiredPropertyException.class, () -> {
             FunctionScore._DESERIALIZER.deserialize(parser, mapper);
        });
        assertEquals("Missing required property 'Builder.<variant kind>'", exception.getMessage());
    }

}

What is the expected behavior?

We should be able to build/deserialize the "weight" type function

What is your host/environment?

MacOs Sonoma

Do you have any screenshots?

N/A

Do you have any additional context?

documentation for score-functions
https://opensearch.org/docs/latest/query-dsl/compound/function-score
https://www.elastic.co/guide/en/elasticsearch/reference/7.17/query-dsl-function-score-query.html#score-functions

[dblock]

Want to contribute the missing code @brentam? Also I would check what we have in https://github.com/opensearch-project/opensearch-api-specification