Tarayıcınızda şöyle bir URL açarsanız:

```
http://127.0.0.1:8000/items/foo-item
```

...zorunlu `needy` parametresini eklemeden, şuna benzer bir hata görürsünüz:

```JSON
{
  "detail": [
    {
      "type": "missing",
      "loc": [
        "query",
        "needy"
      ],
      "msg": "Field required",
      "input": null

{"name": "Portal Gun", "description": "A portal opening device."}
{"name": "Meeseeks Box", "description": "A box that summons a Meeseeks."}
```

Bir JSON dizisine (Python list eşdeğeri) çok benzer; ancak öğeler `[]` içine alınmak ve araya `,` konmak yerine, her satırda **bir JSON nesnesi** vardır; bunlar yeni satır karakteri ile ayrılır.

/// info | Bilgi

**Example:**

Source:
Let's see how that works and how to change it if you need to do that.

Avoid translating literally as:
Vamos ver como isso funciona e como alterar isso se você precisar fazer isso.

Better translation:
Vamos ver como isso funciona e como alterar se você precisar.

---

For the next terms, use the following translations:

* /// check: /// check | Verifique
* /// danger: /// danger | Cuidado

        artifactTypes.getByName("jar") {
            attributes.attribute(minified, java.lang.Boolean.FALSE)
        }
        /*
         * It would perhaps be better to do this more selectively instead of applying this transform so broadly and having
         * it just no-op in most cases.
         */
        registerTransform(Minify::class) {

     * have the same nullness as E." Since we can't, we declare it to return nullable elements, and
     * we can override it in our non-null-guaranteeing subtypes to present a better signature to
     * their users.
     *
     * However, the checker *we* use has this special knowledge about `Collection.toArray()` anyway,

        return readDirect(b, off, len);
    }

    /**
     * Reads up to len bytes of data from this input stream into an array of bytes.
     * Optimized for better performance with larger read sizes and reduced round trips.
     *
     * @param b the buffer to read into
     * @param off the offset in the buffer to start writing
     * @param len the maximum number of bytes to read

 * {@link #putString(CharSequence, Charset)} is generally only useful for cross-language
 * compatibility (otherwise prefer {@link #putUnencodedChars}). However, the character encodings
 * must be identical across languages. Also beware that {@link Charset} definitions may occasionally
 * change between Java releases.
 *
 * <p><b>Warning:</b> Chunks of data that are put into the {@link Hasher} are not delimited. The

    Java Language specification, sections 8.1.1, 8.3.1 and 8.4.3. It is not that
    the standard is perfect, but having a consistent order makes the code more
    readable and no other order is compellingly better than the standard.
    The correct order is:
            public
            protected
            private
            abstract
            static
            final
            transient
            volatile

			// with dead end because tcp-keepalive is not fired when there is data in the socket buffer.
			//    https://blog.cloudflare.com/when-tcp-sockets-refuse-to-die/
			// This is a sensitive configuration, it is better to set it to high values, > 60 secs since it can
			// affect clients reading data with a very slow pace  (disappropriate with socket buffer sizes)
			if opts.UserTimeout > 0 {

            // Log circuit breaker rejection
            auditLogger.logSecurityViolation("Circuit breaker open for SMB connection",
                    java.util.Map.of("address", address.getHostAddress(), "port", String.valueOf(port)));
            throw new IOException("Connection rejected by circuit breaker: " + e.getMessage(), e);
        } catch (RuntimeException e) {