value:           camelBack
  - key:             readability-identifier-naming.MemberCase
    value:           camelBack
  - key:             readability-identifier-naming.ParameterCase
    value:           camelBack
  - key:             readability-identifier-naming.UnionCase
    value:           CamelCase
  - key:             readability-identifier-naming.VariableCase
    value:           camelBack

    # Serialization rules for more complex scenarios
    content: Optional[Dict[str, MediaType]] = None


class Parameter(ParameterBase):
    name: str
    in_: ParameterInType = Field(alias="in")


class Header(ParameterBase):
    pass


class RequestBody(BaseModelWithConfig):
    description: Optional[str] = None
    content: Dict[str, MediaType]

            doColumn("expiredTime");
        }

        public void columnName() {
            doColumn("name");
        }

        public void columnParameterName() {
            doColumn("parameter_name");
        }

        public void columnPermissions() {
            doColumn("permissions");
        }

        public void columnToken() {
            doColumn("token");
        }

- [`KT-58447`](https://youtrack.jetbrains.com/issue/KT-58447) K1: "AssertionError: Recursion detected on input" with `@ParameterName` and extension
- [`KT-41013`](https://youtrack.jetbrains.com/issue/KT-41013) OVERLOAD_RESOLUTION_AMBIGUITY for functions  takes lambda: can not resolve it, but only named lambda parameter

Die meisten Standard-Header benutzen als Trennzeichen einen Bindestrich, auch bekannt als das „Minus-Symbol“ (`-`).

Aber eine Variable wie `user-agent` ist in Python nicht gültig.

Darum wird `Header` standardmäßig in Parameternamen den Unterstrich (`_`) zu einem Bindestrich (`-`) konvertieren.

            result.setExpiredTime(DfTypeUtil.toLong(source.get("expiredTime")));
            result.setName(DfTypeUtil.toString(source.get("name")));
            result.setParameterName(DfTypeUtil.toString(source.get("parameter_name")));
            result.setPermissions(toStringArray(source.get("permissions")));
            result.setToken(DfTypeUtil.toString(source.get("token")));

    ```

In diesem Fall wird **FastAPI** bemerken, dass es mehr als einen Body-Parameter in der Funktion gibt (zwei Parameter, die Pydantic-Modelle sind).

Es wird deshalb die Parameternamen als Schlüssel (Feldnamen) im Body verwenden, und erwartet einen Body wie folgt:

```JSON
{
    "item": {
        "name": "Foo",
        "description": "The pretender",
        "price": 42.0,
        "tax": 3.2

	case "post":
		endpoints.AddObjectParams(b.ws, route, &metav1.CreateOptions{})
	case "delete":
		endpoints.AddObjectParams(b.ws, route, &metav1.DeleteOptions{})
		route.Reads(&metav1.DeleteOptions{}).ParameterNamed("body").Required(false)
	}

	// Build responses
	switch actionVerb {
	case "post":
		route.Returns(http.StatusAccepted, "Accepted", sample)
		route.Returns(http.StatusCreated, "Created", sample)

				Returns(http.StatusOK, "OK", deleteReturnType).
				Returns(http.StatusAccepted, "Accepted", deleteReturnType)
			if isGracefulDeleter {
				route.Reads(versionedDeleterObject)
				route.ParameterNamed("body").Required(false)
				if err := AddObjectParams(ws, route, versionedDeleteOptions); err != nil {
					return nil, nil, err
				}
			}
			addParams(route, action.Params)
			routes = append(routes, route)