# Request Parameters

Here's the reference information for the request parameters.

These are the special functions that you can put in *path operation function* parameters or dependency functions with `Annotated` to get data from the request.

It includes:

* `Query()`
* `Path()`
* `Body()`
* `Cookie()`
* `Header()`
* `Form()`
* `File()`

You can import them all directly from `fastapi`:

```python

     */
    @Nonnull
    String defaultValue() default "";

    /**
     * is the parameter required?
     * @return <code>true</code> if the Mojo should fail when the parameter cannot be injected
     */
    boolean required() default false;

    /**
     * Specifies that this parameter cannot be configured directly by the user (as in the case of POM-specified

# Body - Multiple Parameters

Now that we have seen how to use `Path` and `Query`, let's see more advanced uses of request body declarations.

## Mix `Path`, `Query` and body parameters

First, of course, you can mix `Path`, `Query` and request body parameter declarations freely and **FastAPI** will know what to do.

And you can also declare body parameters as optional, by setting the default to `None`:

//// tab | Python 3.10+

  fun emptyCache(parameters: Pair<FileSystem, Boolean>) {
    setUp(parameters.first, parameters.second)
    cache.close()
    assertJournalEquals()
  }

  @ParameterizedTest
  @ArgumentsSource(FileSystemParamProvider::class)
  fun recoverFromInitializationFailure(parameters: Pair<FileSystem, Boolean>) {
    setUp(parameters.first, parameters.second)

# Query Parameter Models

If you have a group of **query parameters** that are related, you can create a **Pydantic model** to declare them.

This would allow you to **re-use the model** in **multiple places** and also to declare validations and metadata for all the parameters at once. 😎

/// note

This is supported since FastAPI version `0.115.0`. 🤓

///

## Query Parameters with a Pydantic Model

{!> ../../docs_src/body/tutorial002_py310.py!}

## Request body + path parameters

You can declare path parameters and request body at the same time.

**FastAPI** will recognize that the function parameters that match path parameters should be **taken from the path**, and that function parameters that are declared to be Pydantic models should be **taken from the request body**.

{!> ../../docs_src/query_params/tutorial002.py!}
```

////

In this case, the function parameter `q` will be optional, and will be `None` by default.

/// check

Also notice that **FastAPI** is smart enough to notice that the path parameter `item_id` is a path parameter and `q` is not, so, it's a query parameter.

///

## Query parameter type conversion

You can also declare `bool` types, and they will be converted:

    }

    public void test_convertParameterMap() {
        String parameters;
        Map<String, String> parameterMap;

        parameters = "";
        parameterMap = ParameterUtil.parse(parameters);
        assertEquals(0, parameterMap.size());

        parameters = "domain";
        parameterMap = ParameterUtil.parse(parameters);
        assertEquals(1, parameterMap.size());

     * <pre>
     * message: {item} is numeric value out of bounds (&lt;{integer} digits&gt;.&lt;{fraction} digits&gt; expected).
     * </pre>
     * @param property The property name for the message. (NotNull)
     * @param fraction The parameter fraction for message. (NotNull)
     * @param integer The parameter integer for message. (NotNull)
     * @return this. (NotNull)

# Header Parameters

You can define Header parameters the same way you define `Query`, `Path` and `Cookie` parameters.

## Import `Header`

First import `Header`:

//// tab | Python 3.10+

```Python hl_lines="3"
{!> ../../docs_src/header_params/tutorial001_an_py310.py!}
```

////

//// tab | Python 3.9+

```Python hl_lines="3"
{!> ../../docs_src/header_params/tutorial001_an_py39.py!}
```

////