}

    public static class LsarQosInfo extends NdrObject {

        public int length;
        public short impersonation_level;
        public byte context_mode;
        public byte effective_only;


        @Override
        public void encode ( NdrBuffer _dst ) throws NdrException {
            _dst.align(4);
            _dst.enc_ndr_long(this.length);

        try (InputStream fis = Files.newInputStream(path)) {
            byte[] buffer = new byte[SHA1_BUFFER_SIZE];
            int read;
            while ((read = fis.read(buffer)) != -1) {
                md.update(buffer, 0, read);
            }
        }
        StringBuilder result = new StringBuilder();
        for (byte b : md.digest()) {
            result.append(String.format("%02x", b));
        }

	// If the request context is canceled, the stream will no longer process requests.
	// Requests sent cannot be used any further by the called.
	Requests chan<- []byte

	muxID uint64
	ctx   context.Context
}

// Send a payload to the remote server.
func (s *Stream) Send(b []byte) error {
	if s.Requests == nil {
		return errors.New("stream does not accept requests")
	}
	select {
	case s.Requests <- b:
		return nil

						Namespace: "default",
						Name:      "istiod",
					},
					CABundle: []byte("ca"),
				},
			},
			{
				Name: fmt.Sprintf("object.%s", istioInjectionWebhookSuffix),
				ClientConfig: admitv1.WebhookClientConfig{
					Service: &admitv1.ServiceReference{
						Namespace: "default",
						Name:      "istiod",
					},
					CABundle: []byte("ca"),
				},
			},
		},
	}
	samplePath               = "/sample/path"

import java.io.Serializable;

import jcifs.smb1.UniAddress;
import jcifs.smb1.util.Hexdump;

public final class NtlmChallenge implements Serializable {

    public byte[] challenge;
    public UniAddress dc;

    NtlmChallenge( byte[] challenge, UniAddress dc ) {
        this.challenge = challenge;
        this.dc = dc;
    }

    public String toString() {
        return "NtlmChallenge[challenge=0x" +

type Wrapper struct {
	*admin.Clusters
}

// MarshalJSON is a custom marshaller to handle protobuf pain
func (w *Wrapper) MarshalJSON() ([]byte, error) {
	return protomarshal.Marshal(w)
}

// UnmarshalJSON is a custom unmarshaller to handle protobuf pain
func (w *Wrapper) UnmarshalJSON(b []byte) error {
	cd := &admin.Clusters{}
	err := protomarshal.UnmarshalAllowUnknown(b, cd)
	*w = Wrapper{cd}
	return err

func (e *Erasure) Encode(ctx context.Context, src io.Reader, writers []io.Writer, buf []byte, quorum int) (total int64, err error) {
	writer := &multiWriter{
		writers:     writers,
		writeQuorum: quorum,
		errs:        make([]error, len(writers)),
	}

	for {
		var blocks [][]byte
		n, err := io.ReadFull(src, buf)
		if err != nil {
			if !IsErrIgnored(err, []error{
				io.EOF,

     */
    boolean isRetainPayload ();


    /**
     * 
     * @return the raw response message
     */
    byte[] getRawPayload ();


    /**
     * @param rawPayload
     */
    void setRawPayload ( byte[] rawPayload );

func init() {
	interval := fmt.Sprintf("%ds", int(resourceMetricsCollectionInterval.Seconds()))
	resourceMetricsHelpMap = map[MetricName]string{
		interfaceRxBytes:  "Bytes received on the interface in " + interval,
		interfaceRxErrors: "Receive errors in " + interval,
		interfaceTxBytes:  "Bytes transmitted in " + interval,
		interfaceTxErrors: "Transmit errors in " + interval,
		total:             "Total memory on the node",

```Python hl_lines="1  18"
{!../../docs_src/response_directly/tutorial002.py!}
```

### `HTMLResponse`

Usa algum texto ou sequência de bytes e retorna uma resposta HTML. Como você leu acima.

### `PlainTextResponse`

Usa algum texto ou sequência de bytes para retornar uma resposta de texto não formatado.

```Python hl_lines="2  7  9"
{!../../docs_src/custom_response/tutorial005.py!}
```