</div>

### Modelo para Saída { #model-for-output }

Mas se você usar o mesmo modelo como saída, como aqui:

{* ../../docs_src/separate_openapi_schemas/tutorial001_py310.py hl[19] *}

... então, como `description` tem um valor padrão, se você **não retornar nada** para esse campo, ele ainda terá o **valor padrão**.

### Modelo para Dados de Resposta de Saída { #model-for-output-response-data }

   * (key) bits 'affects' a strictly smaller set of output bits. Funneling is bad because it can
   * result in more-than-ideal collisions for a non-uniformly distributed key space. In practice,
   * most key spaces are ANYTHING BUT uniformly distributed. A bit(i) in the input is said to
   * 'affect' a bit(j) in the output if two inputs, identical but for bit(i), will differ at output
   * bit(j) about half the time
   *

        println(failure)
      }
      throw failures.first()
    }
  }

  private fun testToAscii(
    input: String,
    output: String?,
    comment: String?,
  ) {
    val url = "https://$input/".toHttpUrlOrNull()
    assertThat(url?.host, name = comment ?: input).isEqualTo(output)
  }

Example:

```sh
minio server /data{1...4}
```

The command takes no flags

```sh
mc support diagnostics myminio/
```

The output printed will be of the form

```sh
● Admin Info ... ✔ 
● CPU ... ✔ 
● Disk Hardware ... ✔ 
● Os Info ... ✔ 
● Mem Info ... ✔ 
● Process Info ... ✔ 
● Config ... ✔ 
● Drive ... ✔ 
● Net ... ✔ 

import org.eclipse.aether.transfer.TransferEvent;

public class SimpleBuildEventListener implements BuildEventListener {

    final Consumer<String> output;

    public SimpleBuildEventListener(Consumer<String> output) {
        this.output = output;
    }

    @Override
    public void sessionStarted(ExecutionEvent event) {}

    @Override
    public void projectStarted(String projectId) {}

    final DataOutput output;
    final ByteArrayOutputStream byteArrayOutputStream;

    ByteArrayDataOutputStream(ByteArrayOutputStream byteArrayOutputStream) {
      this.byteArrayOutputStream = byteArrayOutputStream;
      output = new DataOutputStream(byteArrayOutputStream);
    }

    @Override
    public void write(int b) {
      try {
        output.write(b);

    validations:
      required: true

  - type: textarea
    id: expected-behavior
    attributes:
      label: "What did you expect to see?"

     *       to the root of the output directory (see {@link Project#getOutputDirectory(ProjectScope)}).</li>
     *   <li><strong>Relative Path</strong> (e.g., {@code Path.of("META-INF/resources")}) - The path is
     *       intended to be resolved relative to the output directory for this source root's {@link #scope()}.
     *       <ul>

     * The error's stacktrace will be output when this error level is enabled.
     *
     * @param content the message to log
     * @param error the error that caused this log
     */
    void debug(CharSequence content, Throwable error);

    /**
     * Sends an exception to the user in the <b>debug</b> error level.
     * The stack trace for this exception will be output when this error level is enabled.
     *

   * (key) bits 'affects' a strictly smaller set of output bits. Funneling is bad because it can
   * result in more-than-ideal collisions for a non-uniformly distributed key space. In practice,
   * most key spaces are ANYTHING BUT uniformly distributed. A bit(i) in the input is said to
   * 'affect' a bit(j) in the output if two inputs, identical but for bit(i), will differ at output
   * bit(j) about half the time
   *