}
            final int size = Encdec.dec_uint16be(sbuf, 2) & 0xFFFF;
            if (size < 33 || 4 + size > sbuf.length) {
                throw new IOException("Invalid payload size: " + size);
            }
            readn(in, sbuf, 4 + 32, size - 32);
            resp.decode(sbuf, 4);

            if (LogStream.level >= 4) {
                log.println(resp);

// The remaining payload and versions are returned.
func checkXL2V1(buf []byte) (payload []byte, major, minor uint16, err error) {
	if len(buf) <= 8 {
		return payload, 0, 0, fmt.Errorf("xlMeta: no data")
	}

	if !bytes.Equal(buf[:4], xlHeader[:]) {
		return payload, 0, 0, fmt.Errorf("xlMeta: unknown XLv2 header, expected %v, got %v", xlHeader[:4], buf[:4])
	}

    "Content-Length": "401",
    "Content-Type": "application/octet-stream",
    "User-Agent": "MinIO (linux; amd64) minio-go/v7.0.70 mc/RELEASE.2024-04-30T17-44-48Z",
    "X-Amz-Content-Sha256": "STREAMING-AWS4-HMAC-SHA256-PAYLOAD",
    "X-Amz-Date": "20240509T073810Z",
    "X-Amz-Decoded-Content-Length": "228"
  },
  "responseHeader": {
    "Accept-Ranges": "bytes",
    "Content-Length": "0",

func (store *QueueStore[I]) Get(key Key) (item I, err error) {
	items, err := store.GetMultiple(key)
	if err != nil {
		return item, err
	}
	return items[0], nil
}

// GetMultiple will read the multi payload file and fetch the items
func (store *QueueStore[I]) GetMultiple(key Key) (items []I, err error) {
	raw, err := store.GetRaw(key)
	if err != nil {
		return nil, err
	}

	ctx, cancel := context.WithCancel(ctx)
	h.storeCtxCancel = cancel
	h.lastStarted = time.Now()
	go h.startQueueProcessor(ctx, true)
	return nil
}

func (h *Target) send(ctx context.Context, payload []byte, payloadCount int, payloadType string, timeout time.Duration) (err error) {
	defer func() {
		if err != nil {
			if xnet.IsNetworkOrHostDown(err, false) {
				h.status.Store(statusOffline)
			}

	case map[string]string:
		m := MSS(typed)
		trace.Path += m.ToQuery()
	case *URLValues:
		trace.Path += typed.Values().Encode()
	case *NoPayload, *Bytes:
		trace.Path = fmt.Sprintf("%s?payload=%T", trace.Path, typed)
	case string:
		trace.Path = fmt.Sprintf("%s?%s", trace.Path, typed)
	default:
	}
	trace.HTTP.ReqInfo.Path = trace.Path

	t.Publisher.Publish(trace)
	return resp, err

			ID:             m.ID,
			Accepted:       false,
			RejectedReason: err.Error(),
		}
		if b, err := resp.MarshalMsg(nil); err == nil {
			msg := message{
				Op:      OpConnectResponse,
				Payload: b,
			}
			if b, err := msg.MarshalMsg(nil); err == nil {
				wsutil.WriteMessage(conn, ws.StateServerSide, ws.OpBinary, b)
			}
		}
	}
	defer conn.Close()
	if debugPrint {

        SMBProtocolDecodingException exception =
                assertThrows(SMBProtocolDecodingException.class, () -> smallResponse.readDataWireFormat(buffer, 0, 10));

        assertEquals("Payload exceeds buffer size", exception.getMessage());
    }

    @ParameterizedTest
    @ValueSource(ints = { 1, 10, 100, 500, 1024 })

Then we use the request directly, and extract the body as `bytes`. This means that FastAPI won't even try to parse the request payload as JSON.

And then in our code, we parse that YAML content directly, and then we are again using the same Pydantic model to validate the YAML content:

> - [**AD/LDAP**](https://github.com/minio/minio/blob/master/docs/sts/ldap.md)