if err != nil {
		return
	}
	err = en.WriteBytes(z.PolicyConfigJSON)
	if err != nil {
		err = msgp.WrapError(err, "PolicyConfigJSON")
		return
	}
	// write "NotificationConfigXML"
	err = en.Append(0xb5, 0x4e, 0x6f, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x58, 0x4d, 0x4c)
	if err != nil {
		return
	}
	err = en.WriteBytes(z.NotificationConfigXML)
	if err != nil {

	// Marshals the item.
	eventData, err := json.Marshal(item)
	if err != nil {
		return err
	}
	return store.writeBytes(key, eventData)
}

// writeBytes - writes bytes to the directory.
func (store *QueueStore[I]) writeBytes(key Key, b []byte) (err error) {
	path := filepath.Join(store.directory, key.String())

	if key.Compress {

		err = en.Append(0xa2, 0x49, 0x44)
		if err != nil {
			return
		}
		err = en.WriteBytes((z.VersionID)[:])
		if err != nil {
			err = msgp.WrapError(err, "VersionID")
			return
		}
		// write "DDir"
		err = en.Append(0xa4, 0x44, 0x44, 0x69, 0x72)
		if err != nil {
			return
		}
		err = en.WriteBytes((z.DataDir)[:])
		if err != nil {
			err = msgp.WrapError(err, "DataDir")
			return

func (z *connectReq) EncodeMsg(en *msgp.Writer) (err error) {
	// map header, size 4
	// write "ID"
	err = en.Append(0x84, 0xa2, 0x49, 0x44)
	if err != nil {
		return
	}
	err = en.WriteBytes((z.ID)[:])
	if err != nil {
		err = msgp.WrapError(err, "ID")
		return
	}
	// write "Host"
	err = en.Append(0xa4, 0x48, 0x6f, 0x73, 0x74)
	if err != nil {
		return
	}

		err = msgp.WrapError(err, "VersionID")
		return
	}
	// write "Versions"
	err = en.Append(0xa8, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x73)
	if err != nil {
		return
	}
	err = en.WriteBytes(z.Versions)
	if err != nil {
		err = msgp.WrapError(err, "Versions")
		return
	}
	// write "SetIndex"
	err = en.Append(0xa8, 0x53, 0x65, 0x74, 0x49, 0x6e, 0x64, 0x65, 0x78)
	if err != nil {
		return

     *
     * @param pathname
     *            The path to the file.
     * @param bytes
     *            The byte array to write.
     */
    public static void writeBytes(final String pathname, final byte[] bytes) {
        try (FileOutputStream fos = OutputStreamUtil.create(new File(pathname))) {
            ChannelUtil.write(fos.getChannel(), ByteBuffer.wrap(bytes));

	if err != nil {
		err = msgp.WrapError(err, "Algorithm")
		return
	}
	// write "Hash"
	err = en.Append(0xa4, 0x48, 0x61, 0x73, 0x68)
	if err != nil {
		return
	}
	err = en.WriteBytes(z.Hash)
	if err != nil {
		err = msgp.WrapError(err, "Hash")
		return
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *ChecksumInfo) MarshalMsg(b []byte) (o []byte, err error) {

				MetricV2{
					Description: getMinioProcessIOReadBytesMD(),
					Value:       float64(io.ReadBytes),
				})
		}

		if io.WriteBytes > 0 {
			metrics = append(metrics,
				MetricV2{
					Description: getMinioProcessIOWriteBytesMD(),
					Value:       float64(io.WriteBytes),
				})
		}

		if io.RChar > 0 {
			metrics = append(metrics,
				MetricV2{

		err = msgp.WrapError(err, "ReplicationState")
		return
	}
	if z.Data == nil { // allownil: if nil
		err = en.WriteNil()
		if err != nil {
			return
		}
	} else {
		err = en.WriteBytes(z.Data)
		if err != nil {
			err = msgp.WrapError(err, "Data")
			return
		}
	}
	err = en.WriteInt(z.NumVersions)
	if err != nil {
		err = msgp.WrapError(err, "NumVersions")
		return