If you declare it as is, because it is a singular value, **FastAPI** will assume that it is a query parameter.

But you can instruct **FastAPI** to treat it as another body key using `Body`:

{* ../../docs_src/body_multiple_params/tutorial003_an_py310.py hl[23] *}


In this case, **FastAPI** will expect a body like:

```JSON
{
    "item": {

// readAllInto reads from r and appends to b until an error or EOF and returns the data it read.
// A successful call returns err == nil, not err == EOF. Because readAllInto is
// defined to read from src until EOF, it does not treat an EOF from Read
// as an error to be reported.
func readAllInto(b []byte, r *wsutil.Reader, want int64) ([]byte, error) {
	read := int64(0)
	for {
		if len(b) == cap(b) {

         * can be used with collections that may contain null. This collection is a collection of
         * non-null Entry objects (Entry objects that might contain null values but are not
         * themselves null), so we can treat it as a plain `Object[]`.
         */
        @SuppressWarnings("nullness")
        Object[] result = standardToArray();
        return result;
      }

      @Override

		// As a special case make sure to trim the separator.

		// NOTE: It is also perfectly fine for windows users to have a path
		// without C:/ since at that point we treat it as relative path
		// and obtain the full filesystem path as well. Providing C:/
		// style is necessary to provide paths other than C:/,
		// such as F:/, D:/ etc.
		//

   */
  @Throws(IOException::class)
  private fun cacheWritingResponse(
    cacheRequest: CacheRequest?,
    response: Response,
  ): Response {
    // Some apps return a null body; for compatibility we treat that like a null cache request.
    if (cacheRequest == null) return response
    val cacheBodyUnbuffered = cacheRequest.body()

    val source = response.body.source()
    val cacheBody = cacheBodyUnbuffered.buffer()

        assertArrayEquals(blob, resp.getBlob());
        assertEquals(0, resp.getSessionFlags());
        assertFalse(resp.isLoggedInAsGuest());
    }

    @Test
    @DisplayName("Decode with ACCESS_DENIED should treat as error response")
    void testDecodeErrorResponsePath() throws Exception {
        Smb2SessionSetupResponse resp = newResponse();

        byte[] buf = new byte[256];
        int headerStart = 0;

                    c = Character.codePointAt(both, 0);
                    i++;
                } catch (IndexOutOfBoundsException ex) {
                    // high surrogate without low surrogate. Not a lot we can do here except treat it as a regular
                    // character
                }
            }

            if (c == '.') {
                if (i == startIndex) {
                    list.add(IntItem.ZERO);

        assertTrue(options.all().get(), "--all option should be true");

        // The plugins option itself won't be set, but the logic in BaseUpgradeGoal
        // should treat --all as enabling plugins
        assertFalse(options.plugins().isPresent(), "--plugins option should not be explicitly set when using --all");
    }

    @Test
    void testLongFormPluginsOption() throws ParseException {

/**
 * A wrapper class for unsigned {@code int} values, supporting arithmetic operations.
 *
 * <p>In some cases, when speed is more important than code readability, it may be faster simply to
 * treat primitive {@code int} values as unsigned, using the methods from {@link UnsignedInts}.
 *
 * <p>See the Guava User Guide article on <a
 * href="https://github.com/google/guava/wiki/PrimitivesExplained#unsigned-support">unsigned

      setException(e);
      return;
    } catch (Error e) {
      /*
       * StackOverflowError, OutOfMemoryError (e.g., from allocating ExecutionException), or
       * something. Try to treat it like a RuntimeException. If we overflow the stack again, the
       * resulting Error will propagate upward up to the root call to set().
       */
      setException(e);
      return;
    }