if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	return
}

// EncodeMsg implements msgp.Encodable
func (z *PartialOperation) EncodeMsg(en *msgp.Writer) (err error) {
	// map header, size 8
	// write "Bucket"
	err = en.Append(0x88, 0xa6, 0x42, 0x75, 0x63, 0x6b, 0x65, 0x74)
	if err != nil {
		return
	}
	err = en.WriteString(z.Bucket)
	if err != nil {
		err = msgp.WrapError(err, "Bucket")

import java.util.concurrent.TimeUnit

/**
 * Observes, modifies, and potentially short-circuits requests going out and the corresponding
 * responses coming back in. Typically interceptors add, remove, or transform headers on the request
 * or response.
 *
 * Implementations of this interface throw [IOException] to signal connectivity failures. This
 * includes both natural exceptions such as unreachable servers, as well as synthetic exceptions

}

h1 {
	font-size: 30px;
}

h2 {
	font-size: 24px;
}

h3 {
	font-size: 18px;
}

.form-control {
	border-radius: 0px;
}

legend{
	display: none;
}

/* header */

#searchOptions {
	position: fixed;
	z-index: 10;
}

#searchOptions .container {
	width: 500px;
	max-width: 100%;
	height: 100%;
	overflow: auto;
	position: fixed;
	top: 0;
	bottom: 0;

But you can return a `JSONResponse` directly from your *path operations*.

It might be useful, for example, to return custom headers or cookies.

## Return a `Response`

In fact, you can return any `Response` or any sub-class of it.

/// tip

`JSONResponse` itself is a sub-class of `Response`.

///

    val request = Builder().url(url).build()
    client.newCall(request)
      .execute()
      .use { response ->
        if (!response.isSuccessful) {
          val responseHeaders = response.headers
          for (i in 0 until responseHeaders.size) {
            println(responseHeaders.name(i) + ": " + responseHeaders.value(i))
          }
          throw IOException("Unexpected code $response")
        }

	data := url.Values{}
	data.Set("grant_type", "client_credentials")
	req, err := http.NewRequest(http.MethodPost, idpEndpoint, strings.NewReader(data.Encode()))
	if err != nil {
		return nil, err
	}
	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
	req.SetBasicAuth(clientID, clientSecret)
	t := &http.Transport{
		TLSClientConfig: &tls.Config{
			InsecureSkipVerify: true,
		},
	}
	hclient := http.Client{

type RequestRecorder struct {
	// Data source to record
	io.Reader
	// Response body should be logged
	LogBody bool

	// internal recording buffer
	buf bytes.Buffer
	// total bytes read including header size
	bytesRead int
}

// Close is a no operation closer
func (r *RequestRecorder) Close() error {
	// no-op
	return nil
}

// Read reads from the internal reader and counts/save the body in the memory

```Python hl_lines="4  10-13"
{!> ../../docs_src/schema_extra_example/tutorial002.py!}
```

////

## `examples` im JSON-Schema – OpenAPI

Bei Verwendung von:

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

können Sie auch eine Gruppe von `examples` mit zusätzlichen Informationen deklarieren, die zu ihren **JSON-Schemas** innerhalb von **OpenAPI** hinzugefügt werden.

import (
	"github.com/tinylib/msgp/msgp"
)

// MarshalMsg implements msgp.Marshaler
func (z *MetricDescription) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 5
	// string "Namespace"
	o = append(o, 0x85, 0xa9, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65)
	o = msgp.AppendString(o, string(z.Namespace))
	// string "Subsystem"

## Contents properties

All properties except the file size are tied to the zip file. This means that modification date, headers, tags, etc. can only be set for the zip file as a whole. In similar fashion, replication will replicate the zip file as a whole and not individual files.

## Code Examples