```Python hl_lines="4  9-12  25-27"
from typing import Union

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()


class Item(BaseModel):
    name: str
    price: float
    is_offer: Union[bool, None] = None


@app.get("/")
def read_root():
    return {"Hello": "World"}


@app.get("/items/{item_id}")
def read_item(item_id: int, q: Union[str, None] = None):

{
  "fess_config.key_match" : {
    "aliases" : { },
    "mappings" : {
      "key_match" : {
        "properties" : {
          "boost" : {
            "type" : "float"
          },
          "createdBy" : {
            "type" : "keyword"
          },
          "createdTime" : {
            "type" : "long"
          },
          "maxSize" : {
            "type" : "integer"
          },
          "query" : {

import json
from pathlib import Path

file_path = Path("./openapi.json")
openapi_content = json.loads(file_path.read_text())

for path_data in openapi_content["paths"].values():
    for operation in path_data.values():
        tag = operation["tags"][0]
        operation_id = operation["operationId"]
        to_remove = f"{tag}-"
        new_operation_id = operation_id[len(to_remove) :]
        operation["operationId"] = new_operation_id

        "short" to "Short",
        "java.lang.Integer" to "Int",
        "int" to "Int",
        "java.lang.Long" to "Long",
        "long" to "Long",
        "java.lang.Float" to "Float",
        "float" to "Float",
        "java.lang.Double" to "Double",
        "double" to "Double"
    )


// See `org.gradle.kotlin.dsl.internal.sharedruntime.codegen.ApiTypeProviderKt.mappedTypeStrings`
private

			input: map[string]interface{}{
				"age": 18,
			},
			expect: clause.Values{
				Columns: []clause.Column{{Name: "age"}},
				Values:  [][]interface{}{{18}},
			},
		},
		{
			name: "Test convert float value",
			input: map[string]interface{}{
				"score": 99.5,
			},
			expect: clause.Values{
				Columns: []clause.Column{{Name: "score"}},
				Values:  [][]interface{}{{99.5}},
			},
		},
		{

     * @param boost the boost factor to apply to the query
     * @return the processed OpenSearch QueryBuilder
     */
    public QueryBuilder execute(final QueryContext context, final Query query, final float boost) {
        return filterChain.execute(context, query, boost);
    }

    /**
     * Adds a query command to the processor.
     *

    @Override
    protected String getQueryClassName() {
        return TermRangeQuery.class.getSimpleName();
    }

    @Override
    public QueryBuilder execute(final QueryContext context, final Query query, final float boost) {
        if (query instanceof final TermRangeQuery termRangeQuery) {
            if (logger.isDebugEnabled()) {
                logger.debug("TermRangeQuery: query={}, boost={}", query, boost);
            }

            if (!(value instanceof Double)) {
                return (T) Double.valueOf(value.toString());
            }
        } else if (clazz.isAssignableFrom(Float.class)) {
            if (!(value instanceof Float)) {
                return (T) Float.valueOf(value.toString());
            }
        } else if (clazz.isAssignableFrom(Boolean.class) && !(value instanceof Boolean)) {

* Datenkonvertierung
* Datenvalidierung
* Automatische Dokumentation

## Spezielle Typen und Validierungen { #special-types-and-validation }

Abgesehen von normalen einfachen Typen wie `str`, `int`, `float`, usw. können Sie komplexere einfache Typen verwenden, die von `str` erben.

     * @throws InvalidQueryException if the query is not a FuzzyQuery
     */
    @Override
    public QueryBuilder execute(final QueryContext context, final Query query, final float boost) {
        if (query instanceof final FuzzyQuery fuzzyQuery) {
            if (logger.isDebugEnabled()) {
                logger.debug("FuzzyQuery: query={}, boost={}", query, boost);
            }