return
		}
	} else {
		err = z.Cache.EncodeMsg(en)
		if err != nil {
			err = msgp.WrapError(err, "Cache")
			return
		}
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *nsScannerOptions) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 3
	// string "id"
	o = append(o, 0x83, 0xa2, 0x69, 0x64)

	if err != nil {
		return
	}
	err = en.WriteUint8(z.dataVersion)
	if err != nil {
		err = msgp.WrapError(err, "dataVersion")
		return
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *metacache) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 13
	// string "end"
	o = append(o, 0x8d, 0xa3, 0x65, 0x6e, 0x64)

	for za0001 := range z.Rules {
		err = z.Rules[za0001].EncodeMsg(en)
		if err != nil {
			err = msgp.WrapError(err, "Rules", za0001)
			return
		}
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *BatchJobExpire) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 6
	// string "APIVersion"

func (z ChecksumAlgo) EncodeMsg(en *msgp.Writer) (err error) {
	err = en.WriteUint8(uint8(z))
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z ChecksumAlgo) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	o = msgp.AppendUint8(o, uint8(z))
	return
}

// UnmarshalMsg implements msgp.Unmarshaler

			expectedErr: errInvalidRuleDelMarkerExpiration,
		},
	}

	for i, tc := range invalidTestCases {
		t.Run(fmt.Sprintf("Test %d", i+1), func(t *testing.T) {
			var rule Rule
			err := xml.Unmarshal([]byte(tc.inputXML), &rule)
			if err != nil {
				t.Fatal(err)
			}

			if err := rule.Validate(); err != tc.expectedErr {
				t.Fatalf("%d: Expected %v but got %v", i+1, tc.expectedErr, err)
			}
		})

	if err != nil {
		return
	}
	err = en.WriteString(z.SessionToken)
	if err != nil {
		err = msgp.WrapError(err, "SessionToken")
		return
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z BatchJobReplicateCredentials) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 3
	// string "AccessKey"

	err = en.Append(0xa1, 0x4e)
	if err != nil {
		return
	}
	err = en.WriteInt64(z.N)
	if err != nil {
		err = msgp.WrapError(err, "N")
		return
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z AccElem) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 3
	// string "Total"
	o = append(o, 0x83, 0xa5, 0x54, 0x6f, 0x74, 0x61, 0x6c)

for the past five days please contact the security team directly:

- Primary security coordinator: ******@****.***
- Secondary coordinator: harsha@min.io
- If you receive no response: ******@****.***

### Disclosure Process

MinIO uses the following disclosure process:

			return
		}
		err = za0002.EncodeMsg(en)
		if err != nil {
			err = msgp.WrapError(err, "Tiers", za0001)
			return
		}
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *TierConfigMgr) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 1
	// string "Tiers"
	o = append(o, 0x81, 0xa5, 0x54, 0x69, 0x65, 0x72, 0x73)

	if err != nil {
		return
	}
	err = en.WriteInt64(z.Bytes)
	if err != nil {
		err = msgp.WrapError(err, "Bytes")
		return
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z RStat) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 2
	// string "Count"
	o = append(o, 0x82, 0xa5, 0x43, 0x6f, 0x75, 0x6e, 0x74)