github.com/minio/minio@v0.0.0-20240328213742-3f72439b8a27/cmd/batch-replicate_gen.go (about)

     1  package cmd
     2  
     3  // Code generated by github.com/tinylib/msgp DO NOT EDIT.
     4  
     5  import (
     6  	"github.com/tinylib/msgp/msgp"
     7  )
     8  
     9  // DecodeMsg implements msgp.Decodable
    10  func (z *BatchJobReplicateCredentials) DecodeMsg(dc *msgp.Reader) (err error) {
    11  	var field []byte
    12  	_ = field
    13  	var zb0001 uint32
    14  	zb0001, err = dc.ReadMapHeader()
    15  	if err != nil {
    16  		err = msgp.WrapError(err)
    17  		return
    18  	}
    19  	for zb0001 > 0 {
    20  		zb0001--
    21  		field, err = dc.ReadMapKeyPtr()
    22  		if err != nil {
    23  			err = msgp.WrapError(err)
    24  			return
    25  		}
    26  		switch msgp.UnsafeString(field) {
    27  		case "AccessKey":
    28  			z.AccessKey, err = dc.ReadString()
    29  			if err != nil {
    30  				err = msgp.WrapError(err, "AccessKey")
    31  				return
    32  			}
    33  		case "SecretKey":
    34  			z.SecretKey, err = dc.ReadString()
    35  			if err != nil {
    36  				err = msgp.WrapError(err, "SecretKey")
    37  				return
    38  			}
    39  		case "SessionToken":
    40  			z.SessionToken, err = dc.ReadString()
    41  			if err != nil {
    42  				err = msgp.WrapError(err, "SessionToken")
    43  				return
    44  			}
    45  		default:
    46  			err = dc.Skip()
    47  			if err != nil {
    48  				err = msgp.WrapError(err)
    49  				return
    50  			}
    51  		}
    52  	}
    53  	return
    54  }
    55  
    56  // EncodeMsg implements msgp.Encodable
    57  func (z BatchJobReplicateCredentials) EncodeMsg(en *msgp.Writer) (err error) {
    58  	// map header, size 3
    59  	// write "AccessKey"
    60  	err = en.Append(0x83, 0xa9, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4b, 0x65, 0x79)
    61  	if err != nil {
    62  		return
    63  	}
    64  	err = en.WriteString(z.AccessKey)
    65  	if err != nil {
    66  		err = msgp.WrapError(err, "AccessKey")
    67  		return
    68  	}
    69  	// write "SecretKey"
    70  	err = en.Append(0xa9, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x4b, 0x65, 0x79)
    71  	if err != nil {
    72  		return
    73  	}
    74  	err = en.WriteString(z.SecretKey)
    75  	if err != nil {
    76  		err = msgp.WrapError(err, "SecretKey")
    77  		return
    78  	}
    79  	// write "SessionToken"
    80  	err = en.Append(0xac, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x54, 0x6f, 0x6b, 0x65, 0x6e)
    81  	if err != nil {
    82  		return
    83  	}
    84  	err = en.WriteString(z.SessionToken)
    85  	if err != nil {
    86  		err = msgp.WrapError(err, "SessionToken")
    87  		return
    88  	}
    89  	return
    90  }
    91  
    92  // MarshalMsg implements msgp.Marshaler
    93  func (z BatchJobReplicateCredentials) MarshalMsg(b []byte) (o []byte, err error) {
    94  	o = msgp.Require(b, z.Msgsize())
    95  	// map header, size 3
    96  	// string "AccessKey"
    97  	o = append(o, 0x83, 0xa9, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4b, 0x65, 0x79)
    98  	o = msgp.AppendString(o, z.AccessKey)
    99  	// string "SecretKey"
   100  	o = append(o, 0xa9, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x4b, 0x65, 0x79)
   101  	o = msgp.AppendString(o, z.SecretKey)
   102  	// string "SessionToken"
   103  	o = append(o, 0xac, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x54, 0x6f, 0x6b, 0x65, 0x6e)
   104  	o = msgp.AppendString(o, z.SessionToken)
   105  	return
   106  }
   107  
   108  // UnmarshalMsg implements msgp.Unmarshaler
   109  func (z *BatchJobReplicateCredentials) UnmarshalMsg(bts []byte) (o []byte, err error) {
   110  	var field []byte
   111  	_ = field
   112  	var zb0001 uint32
   113  	zb0001, bts, err = msgp.ReadMapHeaderBytes(bts)
   114  	if err != nil {
   115  		err = msgp.WrapError(err)
   116  		return
   117  	}
   118  	for zb0001 > 0 {
   119  		zb0001--
   120  		field, bts, err = msgp.ReadMapKeyZC(bts)
   121  		if err != nil {
   122  			err = msgp.WrapError(err)
   123  			return
   124  		}
   125  		switch msgp.UnsafeString(field) {
   126  		case "AccessKey":
   127  			z.AccessKey, bts, err = msgp.ReadStringBytes(bts)
   128  			if err != nil {
   129  				err = msgp.WrapError(err, "AccessKey")
   130  				return
   131  			}
   132  		case "SecretKey":
   133  			z.SecretKey, bts, err = msgp.ReadStringBytes(bts)
   134  			if err != nil {
   135  				err = msgp.WrapError(err, "SecretKey")
   136  				return
   137  			}
   138  		case "SessionToken":
   139  			z.SessionToken, bts, err = msgp.ReadStringBytes(bts)
   140  			if err != nil {
   141  				err = msgp.WrapError(err, "SessionToken")
   142  				return
   143  			}
   144  		default:
   145  			bts, err = msgp.Skip(bts)
   146  			if err != nil {
   147  				err = msgp.WrapError(err)
   148  				return
   149  			}
   150  		}
   151  	}
   152  	o = bts
   153  	return
   154  }
   155  
   156  // Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
   157  func (z BatchJobReplicateCredentials) Msgsize() (s int) {
   158  	s = 1 + 10 + msgp.StringPrefixSize + len(z.AccessKey) + 10 + msgp.StringPrefixSize + len(z.SecretKey) + 13 + msgp.StringPrefixSize + len(z.SessionToken)
   159  	return
   160  }
   161  
   162  // DecodeMsg implements msgp.Decodable
   163  func (z *BatchJobReplicateFlags) DecodeMsg(dc *msgp.Reader) (err error) {
   164  	var field []byte
   165  	_ = field
   166  	var zb0001 uint32
   167  	zb0001, err = dc.ReadMapHeader()
   168  	if err != nil {
   169  		err = msgp.WrapError(err)
   170  		return
   171  	}
   172  	for zb0001 > 0 {
   173  		zb0001--
   174  		field, err = dc.ReadMapKeyPtr()
   175  		if err != nil {
   176  			err = msgp.WrapError(err)
   177  			return
   178  		}
   179  		switch msgp.UnsafeString(field) {
   180  		case "Filter":
   181  			err = z.Filter.DecodeMsg(dc)
   182  			if err != nil {
   183  				err = msgp.WrapError(err, "Filter")
   184  				return
   185  			}
   186  		case "Notify":
   187  			err = z.Notify.DecodeMsg(dc)
   188  			if err != nil {
   189  				err = msgp.WrapError(err, "Notify")
   190  				return
   191  			}
   192  		case "Retry":
   193  			err = z.Retry.DecodeMsg(dc)
   194  			if err != nil {
   195  				err = msgp.WrapError(err, "Retry")
   196  				return
   197  			}
   198  		default:
   199  			err = dc.Skip()
   200  			if err != nil {
   201  				err = msgp.WrapError(err)
   202  				return
   203  			}
   204  		}
   205  	}
   206  	return
   207  }
   208  
   209  // EncodeMsg implements msgp.Encodable
   210  func (z *BatchJobReplicateFlags) EncodeMsg(en *msgp.Writer) (err error) {
   211  	// map header, size 3
   212  	// write "Filter"
   213  	err = en.Append(0x83, 0xa6, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72)
   214  	if err != nil {
   215  		return
   216  	}
   217  	err = z.Filter.EncodeMsg(en)
   218  	if err != nil {
   219  		err = msgp.WrapError(err, "Filter")
   220  		return
   221  	}
   222  	// write "Notify"
   223  	err = en.Append(0xa6, 0x4e, 0x6f, 0x74, 0x69, 0x66, 0x79)
   224  	if err != nil {
   225  		return
   226  	}
   227  	err = z.Notify.EncodeMsg(en)
   228  	if err != nil {
   229  		err = msgp.WrapError(err, "Notify")
   230  		return
   231  	}
   232  	// write "Retry"
   233  	err = en.Append(0xa5, 0x52, 0x65, 0x74, 0x72, 0x79)
   234  	if err != nil {
   235  		return
   236  	}
   237  	err = z.Retry.EncodeMsg(en)
   238  	if err != nil {
   239  		err = msgp.WrapError(err, "Retry")
   240  		return
   241  	}
   242  	return
   243  }
   244  
   245  // MarshalMsg implements msgp.Marshaler
   246  func (z *BatchJobReplicateFlags) MarshalMsg(b []byte) (o []byte, err error) {
   247  	o = msgp.Require(b, z.Msgsize())
   248  	// map header, size 3
   249  	// string "Filter"
   250  	o = append(o, 0x83, 0xa6, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72)
   251  	o, err = z.Filter.MarshalMsg(o)
   252  	if err != nil {
   253  		err = msgp.WrapError(err, "Filter")
   254  		return
   255  	}
   256  	// string "Notify"
   257  	o = append(o, 0xa6, 0x4e, 0x6f, 0x74, 0x69, 0x66, 0x79)
   258  	o, err = z.Notify.MarshalMsg(o)
   259  	if err != nil {
   260  		err = msgp.WrapError(err, "Notify")
   261  		return
   262  	}
   263  	// string "Retry"
   264  	o = append(o, 0xa5, 0x52, 0x65, 0x74, 0x72, 0x79)
   265  	o, err = z.Retry.MarshalMsg(o)
   266  	if err != nil {
   267  		err = msgp.WrapError(err, "Retry")
   268  		return
   269  	}
   270  	return
   271  }
   272  
   273  // UnmarshalMsg implements msgp.Unmarshaler
   274  func (z *BatchJobReplicateFlags) UnmarshalMsg(bts []byte) (o []byte, err error) {
   275  	var field []byte
   276  	_ = field
   277  	var zb0001 uint32
   278  	zb0001, bts, err = msgp.ReadMapHeaderBytes(bts)
   279  	if err != nil {
   280  		err = msgp.WrapError(err)
   281  		return
   282  	}
   283  	for zb0001 > 0 {
   284  		zb0001--
   285  		field, bts, err = msgp.ReadMapKeyZC(bts)
   286  		if err != nil {
   287  			err = msgp.WrapError(err)
   288  			return
   289  		}
   290  		switch msgp.UnsafeString(field) {
   291  		case "Filter":
   292  			bts, err = z.Filter.UnmarshalMsg(bts)
   293  			if err != nil {
   294  				err = msgp.WrapError(err, "Filter")
   295  				return
   296  			}
   297  		case "Notify":
   298  			bts, err = z.Notify.UnmarshalMsg(bts)
   299  			if err != nil {
   300  				err = msgp.WrapError(err, "Notify")
   301  				return
   302  			}
   303  		case "Retry":
   304  			bts, err = z.Retry.UnmarshalMsg(bts)
   305  			if err != nil {
   306  				err = msgp.WrapError(err, "Retry")
   307  				return
   308  			}
   309  		default:
   310  			bts, err = msgp.Skip(bts)
   311  			if err != nil {
   312  				err = msgp.WrapError(err)
   313  				return
   314  			}
   315  		}
   316  	}
   317  	o = bts
   318  	return
   319  }
   320  
   321  // Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
   322  func (z *BatchJobReplicateFlags) Msgsize() (s int) {
   323  	s = 1 + 7 + z.Filter.Msgsize() + 7 + z.Notify.Msgsize() + 6 + z.Retry.Msgsize()
   324  	return
   325  }
   326  
   327  // DecodeMsg implements msgp.Decodable
   328  func (z *BatchJobReplicateResourceType) DecodeMsg(dc *msgp.Reader) (err error) {
   329  	{
   330  		var zb0001 string
   331  		zb0001, err = dc.ReadString()
   332  		if err != nil {
   333  			err = msgp.WrapError(err)
   334  			return
   335  		}
   336  		(*z) = BatchJobReplicateResourceType(zb0001)
   337  	}
   338  	return
   339  }
   340  
   341  // EncodeMsg implements msgp.Encodable
   342  func (z BatchJobReplicateResourceType) EncodeMsg(en *msgp.Writer) (err error) {
   343  	err = en.WriteString(string(z))
   344  	if err != nil {
   345  		err = msgp.WrapError(err)
   346  		return
   347  	}
   348  	return
   349  }
   350  
   351  // MarshalMsg implements msgp.Marshaler
   352  func (z BatchJobReplicateResourceType) MarshalMsg(b []byte) (o []byte, err error) {
   353  	o = msgp.Require(b, z.Msgsize())
   354  	o = msgp.AppendString(o, string(z))
   355  	return
   356  }
   357  
   358  // UnmarshalMsg implements msgp.Unmarshaler
   359  func (z *BatchJobReplicateResourceType) UnmarshalMsg(bts []byte) (o []byte, err error) {
   360  	{
   361  		var zb0001 string
   362  		zb0001, bts, err = msgp.ReadStringBytes(bts)
   363  		if err != nil {
   364  			err = msgp.WrapError(err)
   365  			return
   366  		}
   367  		(*z) = BatchJobReplicateResourceType(zb0001)
   368  	}
   369  	o = bts
   370  	return
   371  }
   372  
   373  // Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
   374  func (z BatchJobReplicateResourceType) Msgsize() (s int) {
   375  	s = msgp.StringPrefixSize + len(string(z))
   376  	return
   377  }
   378  
   379  // DecodeMsg implements msgp.Decodable
   380  func (z *BatchJobReplicateSource) DecodeMsg(dc *msgp.Reader) (err error) {
   381  	var field []byte
   382  	_ = field
   383  	var zb0001 uint32
   384  	zb0001, err = dc.ReadMapHeader()
   385  	if err != nil {
   386  		err = msgp.WrapError(err)
   387  		return
   388  	}
   389  	for zb0001 > 0 {
   390  		zb0001--
   391  		field, err = dc.ReadMapKeyPtr()
   392  		if err != nil {
   393  			err = msgp.WrapError(err)
   394  			return
   395  		}
   396  		switch msgp.UnsafeString(field) {
   397  		case "Type":
   398  			{
   399  				var zb0002 string
   400  				zb0002, err = dc.ReadString()
   401  				if err != nil {
   402  					err = msgp.WrapError(err, "Type")
   403  					return
   404  				}
   405  				z.Type = BatchJobReplicateResourceType(zb0002)
   406  			}
   407  		case "Bucket":
   408  			z.Bucket, err = dc.ReadString()
   409  			if err != nil {
   410  				err = msgp.WrapError(err, "Bucket")
   411  				return
   412  			}
   413  		case "Prefix":
   414  			z.Prefix, err = dc.ReadString()
   415  			if err != nil {
   416  				err = msgp.WrapError(err, "Prefix")
   417  				return
   418  			}
   419  		case "Endpoint":
   420  			z.Endpoint, err = dc.ReadString()
   421  			if err != nil {
   422  				err = msgp.WrapError(err, "Endpoint")
   423  				return
   424  			}
   425  		case "Path":
   426  			z.Path, err = dc.ReadString()
   427  			if err != nil {
   428  				err = msgp.WrapError(err, "Path")
   429  				return
   430  			}
   431  		case "Creds":
   432  			var zb0003 uint32
   433  			zb0003, err = dc.ReadMapHeader()
   434  			if err != nil {
   435  				err = msgp.WrapError(err, "Creds")
   436  				return
   437  			}
   438  			for zb0003 > 0 {
   439  				zb0003--
   440  				field, err = dc.ReadMapKeyPtr()
   441  				if err != nil {
   442  					err = msgp.WrapError(err, "Creds")
   443  					return
   444  				}
   445  				switch msgp.UnsafeString(field) {
   446  				case "AccessKey":
   447  					z.Creds.AccessKey, err = dc.ReadString()
   448  					if err != nil {
   449  						err = msgp.WrapError(err, "Creds", "AccessKey")
   450  						return
   451  					}
   452  				case "SecretKey":
   453  					z.Creds.SecretKey, err = dc.ReadString()
   454  					if err != nil {
   455  						err = msgp.WrapError(err, "Creds", "SecretKey")
   456  						return
   457  					}
   458  				case "SessionToken":
   459  					z.Creds.SessionToken, err = dc.ReadString()
   460  					if err != nil {
   461  						err = msgp.WrapError(err, "Creds", "SessionToken")
   462  						return
   463  					}
   464  				default:
   465  					err = dc.Skip()
   466  					if err != nil {
   467  						err = msgp.WrapError(err, "Creds")
   468  						return
   469  					}
   470  				}
   471  			}
   472  		case "Snowball":
   473  			err = z.Snowball.DecodeMsg(dc)
   474  			if err != nil {
   475  				err = msgp.WrapError(err, "Snowball")
   476  				return
   477  			}
   478  		default:
   479  			err = dc.Skip()
   480  			if err != nil {
   481  				err = msgp.WrapError(err)
   482  				return
   483  			}
   484  		}
   485  	}
   486  	return
   487  }
   488  
   489  // EncodeMsg implements msgp.Encodable
   490  func (z *BatchJobReplicateSource) EncodeMsg(en *msgp.Writer) (err error) {
   491  	// map header, size 7
   492  	// write "Type"
   493  	err = en.Append(0x87, 0xa4, 0x54, 0x79, 0x70, 0x65)
   494  	if err != nil {
   495  		return
   496  	}
   497  	err = en.WriteString(string(z.Type))
   498  	if err != nil {
   499  		err = msgp.WrapError(err, "Type")
   500  		return
   501  	}
   502  	// write "Bucket"
   503  	err = en.Append(0xa6, 0x42, 0x75, 0x63, 0x6b, 0x65, 0x74)
   504  	if err != nil {
   505  		return
   506  	}
   507  	err = en.WriteString(z.Bucket)
   508  	if err != nil {
   509  		err = msgp.WrapError(err, "Bucket")
   510  		return
   511  	}
   512  	// write "Prefix"
   513  	err = en.Append(0xa6, 0x50, 0x72, 0x65, 0x66, 0x69, 0x78)
   514  	if err != nil {
   515  		return
   516  	}
   517  	err = en.WriteString(z.Prefix)
   518  	if err != nil {
   519  		err = msgp.WrapError(err, "Prefix")
   520  		return
   521  	}
   522  	// write "Endpoint"
   523  	err = en.Append(0xa8, 0x45, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74)
   524  	if err != nil {
   525  		return
   526  	}
   527  	err = en.WriteString(z.Endpoint)
   528  	if err != nil {
   529  		err = msgp.WrapError(err, "Endpoint")
   530  		return
   531  	}
   532  	// write "Path"
   533  	err = en.Append(0xa4, 0x50, 0x61, 0x74, 0x68)
   534  	if err != nil {
   535  		return
   536  	}
   537  	err = en.WriteString(z.Path)
   538  	if err != nil {
   539  		err = msgp.WrapError(err, "Path")
   540  		return
   541  	}
   542  	// write "Creds"
   543  	err = en.Append(0xa5, 0x43, 0x72, 0x65, 0x64, 0x73)
   544  	if err != nil {
   545  		return
   546  	}
   547  	// map header, size 3
   548  	// write "AccessKey"
   549  	err = en.Append(0x83, 0xa9, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4b, 0x65, 0x79)
   550  	if err != nil {
   551  		return
   552  	}
   553  	err = en.WriteString(z.Creds.AccessKey)
   554  	if err != nil {
   555  		err = msgp.WrapError(err, "Creds", "AccessKey")
   556  		return
   557  	}
   558  	// write "SecretKey"
   559  	err = en.Append(0xa9, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x4b, 0x65, 0x79)
   560  	if err != nil {
   561  		return
   562  	}
   563  	err = en.WriteString(z.Creds.SecretKey)
   564  	if err != nil {
   565  		err = msgp.WrapError(err, "Creds", "SecretKey")
   566  		return
   567  	}
   568  	// write "SessionToken"
   569  	err = en.Append(0xac, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x54, 0x6f, 0x6b, 0x65, 0x6e)
   570  	if err != nil {
   571  		return
   572  	}
   573  	err = en.WriteString(z.Creds.SessionToken)
   574  	if err != nil {
   575  		err = msgp.WrapError(err, "Creds", "SessionToken")
   576  		return
   577  	}
   578  	// write "Snowball"
   579  	err = en.Append(0xa8, 0x53, 0x6e, 0x6f, 0x77, 0x62, 0x61, 0x6c, 0x6c)
   580  	if err != nil {
   581  		return
   582  	}
   583  	err = z.Snowball.EncodeMsg(en)
   584  	if err != nil {
   585  		err = msgp.WrapError(err, "Snowball")
   586  		return
   587  	}
   588  	return
   589  }
   590  
   591  // MarshalMsg implements msgp.Marshaler
   592  func (z *BatchJobReplicateSource) MarshalMsg(b []byte) (o []byte, err error) {
   593  	o = msgp.Require(b, z.Msgsize())
   594  	// map header, size 7
   595  	// string "Type"
   596  	o = append(o, 0x87, 0xa4, 0x54, 0x79, 0x70, 0x65)
   597  	o = msgp.AppendString(o, string(z.Type))
   598  	// string "Bucket"
   599  	o = append(o, 0xa6, 0x42, 0x75, 0x63, 0x6b, 0x65, 0x74)
   600  	o = msgp.AppendString(o, z.Bucket)
   601  	// string "Prefix"
   602  	o = append(o, 0xa6, 0x50, 0x72, 0x65, 0x66, 0x69, 0x78)
   603  	o = msgp.AppendString(o, z.Prefix)
   604  	// string "Endpoint"
   605  	o = append(o, 0xa8, 0x45, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74)
   606  	o = msgp.AppendString(o, z.Endpoint)
   607  	// string "Path"
   608  	o = append(o, 0xa4, 0x50, 0x61, 0x74, 0x68)
   609  	o = msgp.AppendString(o, z.Path)
   610  	// string "Creds"
   611  	o = append(o, 0xa5, 0x43, 0x72, 0x65, 0x64, 0x73)
   612  	// map header, size 3
   613  	// string "AccessKey"
   614  	o = append(o, 0x83, 0xa9, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4b, 0x65, 0x79)
   615  	o = msgp.AppendString(o, z.Creds.AccessKey)
   616  	// string "SecretKey"
   617  	o = append(o, 0xa9, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x4b, 0x65, 0x79)
   618  	o = msgp.AppendString(o, z.Creds.SecretKey)
   619  	// string "SessionToken"
   620  	o = append(o, 0xac, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x54, 0x6f, 0x6b, 0x65, 0x6e)
   621  	o = msgp.AppendString(o, z.Creds.SessionToken)
   622  	// string "Snowball"
   623  	o = append(o, 0xa8, 0x53, 0x6e, 0x6f, 0x77, 0x62, 0x61, 0x6c, 0x6c)
   624  	o, err = z.Snowball.MarshalMsg(o)
   625  	if err != nil {
   626  		err = msgp.WrapError(err, "Snowball")
   627  		return
   628  	}
   629  	return
   630  }
   631  
   632  // UnmarshalMsg implements msgp.Unmarshaler
   633  func (z *BatchJobReplicateSource) UnmarshalMsg(bts []byte) (o []byte, err error) {
   634  	var field []byte
   635  	_ = field
   636  	var zb0001 uint32
   637  	zb0001, bts, err = msgp.ReadMapHeaderBytes(bts)
   638  	if err != nil {
   639  		err = msgp.WrapError(err)
   640  		return
   641  	}
   642  	for zb0001 > 0 {
   643  		zb0001--
   644  		field, bts, err = msgp.ReadMapKeyZC(bts)
   645  		if err != nil {
   646  			err = msgp.WrapError(err)
   647  			return
   648  		}
   649  		switch msgp.UnsafeString(field) {
   650  		case "Type":
   651  			{
   652  				var zb0002 string
   653  				zb0002, bts, err = msgp.ReadStringBytes(bts)
   654  				if err != nil {
   655  					err = msgp.WrapError(err, "Type")
   656  					return
   657  				}
   658  				z.Type = BatchJobReplicateResourceType(zb0002)
   659  			}
   660  		case "Bucket":
   661  			z.Bucket, bts, err = msgp.ReadStringBytes(bts)
   662  			if err != nil {
   663  				err = msgp.WrapError(err, "Bucket")
   664  				return
   665  			}
   666  		case "Prefix":
   667  			z.Prefix, bts, err = msgp.ReadStringBytes(bts)
   668  			if err != nil {
   669  				err = msgp.WrapError(err, "Prefix")
   670  				return
   671  			}
   672  		case "Endpoint":
   673  			z.Endpoint, bts, err = msgp.ReadStringBytes(bts)
   674  			if err != nil {
   675  				err = msgp.WrapError(err, "Endpoint")
   676  				return
   677  			}
   678  		case "Path":
   679  			z.Path, bts, err = msgp.ReadStringBytes(bts)
   680  			if err != nil {
   681  				err = msgp.WrapError(err, "Path")
   682  				return
   683  			}
   684  		case "Creds":
   685  			var zb0003 uint32
   686  			zb0003, bts, err = msgp.ReadMapHeaderBytes(bts)
   687  			if err != nil {
   688  				err = msgp.WrapError(err, "Creds")
   689  				return
   690  			}
   691  			for zb0003 > 0 {
   692  				zb0003--
   693  				field, bts, err = msgp.ReadMapKeyZC(bts)
   694  				if err != nil {
   695  					err = msgp.WrapError(err, "Creds")
   696  					return
   697  				}
   698  				switch msgp.UnsafeString(field) {
   699  				case "AccessKey":
   700  					z.Creds.AccessKey, bts, err = msgp.ReadStringBytes(bts)
   701  					if err != nil {
   702  						err = msgp.WrapError(err, "Creds", "AccessKey")
   703  						return
   704  					}
   705  				case "SecretKey":
   706  					z.Creds.SecretKey, bts, err = msgp.ReadStringBytes(bts)
   707  					if err != nil {
   708  						err = msgp.WrapError(err, "Creds", "SecretKey")
   709  						return
   710  					}
   711  				case "SessionToken":
   712  					z.Creds.SessionToken, bts, err = msgp.ReadStringBytes(bts)
   713  					if err != nil {
   714  						err = msgp.WrapError(err, "Creds", "SessionToken")
   715  						return
   716  					}
   717  				default:
   718  					bts, err = msgp.Skip(bts)
   719  					if err != nil {
   720  						err = msgp.WrapError(err, "Creds")
   721  						return
   722  					}
   723  				}
   724  			}
   725  		case "Snowball":
   726  			bts, err = z.Snowball.UnmarshalMsg(bts)
   727  			if err != nil {
   728  				err = msgp.WrapError(err, "Snowball")
   729  				return
   730  			}
   731  		default:
   732  			bts, err = msgp.Skip(bts)
   733  			if err != nil {
   734  				err = msgp.WrapError(err)
   735  				return
   736  			}
   737  		}
   738  	}
   739  	o = bts
   740  	return
   741  }
   742  
   743  // Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
   744  func (z *BatchJobReplicateSource) Msgsize() (s int) {
   745  	s = 1 + 5 + msgp.StringPrefixSize + len(string(z.Type)) + 7 + msgp.StringPrefixSize + len(z.Bucket) + 7 + msgp.StringPrefixSize + len(z.Prefix) + 9 + msgp.StringPrefixSize + len(z.Endpoint) + 5 + msgp.StringPrefixSize + len(z.Path) + 6 + 1 + 10 + msgp.StringPrefixSize + len(z.Creds.AccessKey) + 10 + msgp.StringPrefixSize + len(z.Creds.SecretKey) + 13 + msgp.StringPrefixSize + len(z.Creds.SessionToken) + 9 + z.Snowball.Msgsize()
   746  	return
   747  }
   748  
   749  // DecodeMsg implements msgp.Decodable
   750  func (z *BatchJobReplicateTarget) DecodeMsg(dc *msgp.Reader) (err error) {
   751  	var field []byte
   752  	_ = field
   753  	var zb0001 uint32
   754  	zb0001, err = dc.ReadMapHeader()
   755  	if err != nil {
   756  		err = msgp.WrapError(err)
   757  		return
   758  	}
   759  	for zb0001 > 0 {
   760  		zb0001--
   761  		field, err = dc.ReadMapKeyPtr()
   762  		if err != nil {
   763  			err = msgp.WrapError(err)
   764  			return
   765  		}
   766  		switch msgp.UnsafeString(field) {
   767  		case "Type":
   768  			{
   769  				var zb0002 string
   770  				zb0002, err = dc.ReadString()
   771  				if err != nil {
   772  					err = msgp.WrapError(err, "Type")
   773  					return
   774  				}
   775  				z.Type = BatchJobReplicateResourceType(zb0002)
   776  			}
   777  		case "Bucket":
   778  			z.Bucket, err = dc.ReadString()
   779  			if err != nil {
   780  				err = msgp.WrapError(err, "Bucket")
   781  				return
   782  			}
   783  		case "Prefix":
   784  			z.Prefix, err = dc.ReadString()
   785  			if err != nil {
   786  				err = msgp.WrapError(err, "Prefix")
   787  				return
   788  			}
   789  		case "Endpoint":
   790  			z.Endpoint, err = dc.ReadString()
   791  			if err != nil {
   792  				err = msgp.WrapError(err, "Endpoint")
   793  				return
   794  			}
   795  		case "Path":
   796  			z.Path, err = dc.ReadString()
   797  			if err != nil {
   798  				err = msgp.WrapError(err, "Path")
   799  				return
   800  			}
   801  		case "Creds":
   802  			var zb0003 uint32
   803  			zb0003, err = dc.ReadMapHeader()
   804  			if err != nil {
   805  				err = msgp.WrapError(err, "Creds")
   806  				return
   807  			}
   808  			for zb0003 > 0 {
   809  				zb0003--
   810  				field, err = dc.ReadMapKeyPtr()
   811  				if err != nil {
   812  					err = msgp.WrapError(err, "Creds")
   813  					return
   814  				}
   815  				switch msgp.UnsafeString(field) {
   816  				case "AccessKey":
   817  					z.Creds.AccessKey, err = dc.ReadString()
   818  					if err != nil {
   819  						err = msgp.WrapError(err, "Creds", "AccessKey")
   820  						return
   821  					}
   822  				case "SecretKey":
   823  					z.Creds.SecretKey, err = dc.ReadString()
   824  					if err != nil {
   825  						err = msgp.WrapError(err, "Creds", "SecretKey")
   826  						return
   827  					}
   828  				case "SessionToken":
   829  					z.Creds.SessionToken, err = dc.ReadString()
   830  					if err != nil {
   831  						err = msgp.WrapError(err, "Creds", "SessionToken")
   832  						return
   833  					}
   834  				default:
   835  					err = dc.Skip()
   836  					if err != nil {
   837  						err = msgp.WrapError(err, "Creds")
   838  						return
   839  					}
   840  				}
   841  			}
   842  		default:
   843  			err = dc.Skip()
   844  			if err != nil {
   845  				err = msgp.WrapError(err)
   846  				return
   847  			}
   848  		}
   849  	}
   850  	return
   851  }
   852  
   853  // EncodeMsg implements msgp.Encodable
   854  func (z *BatchJobReplicateTarget) EncodeMsg(en *msgp.Writer) (err error) {
   855  	// map header, size 6
   856  	// write "Type"
   857  	err = en.Append(0x86, 0xa4, 0x54, 0x79, 0x70, 0x65)
   858  	if err != nil {
   859  		return
   860  	}
   861  	err = en.WriteString(string(z.Type))
   862  	if err != nil {
   863  		err = msgp.WrapError(err, "Type")
   864  		return
   865  	}
   866  	// write "Bucket"
   867  	err = en.Append(0xa6, 0x42, 0x75, 0x63, 0x6b, 0x65, 0x74)
   868  	if err != nil {
   869  		return
   870  	}
   871  	err = en.WriteString(z.Bucket)
   872  	if err != nil {
   873  		err = msgp.WrapError(err, "Bucket")
   874  		return
   875  	}
   876  	// write "Prefix"
   877  	err = en.Append(0xa6, 0x50, 0x72, 0x65, 0x66, 0x69, 0x78)
   878  	if err != nil {
   879  		return
   880  	}
   881  	err = en.WriteString(z.Prefix)
   882  	if err != nil {
   883  		err = msgp.WrapError(err, "Prefix")
   884  		return
   885  	}
   886  	// write "Endpoint"
   887  	err = en.Append(0xa8, 0x45, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74)
   888  	if err != nil {
   889  		return
   890  	}
   891  	err = en.WriteString(z.Endpoint)
   892  	if err != nil {
   893  		err = msgp.WrapError(err, "Endpoint")
   894  		return
   895  	}
   896  	// write "Path"
   897  	err = en.Append(0xa4, 0x50, 0x61, 0x74, 0x68)
   898  	if err != nil {
   899  		return
   900  	}
   901  	err = en.WriteString(z.Path)
   902  	if err != nil {
   903  		err = msgp.WrapError(err, "Path")
   904  		return
   905  	}
   906  	// write "Creds"
   907  	err = en.Append(0xa5, 0x43, 0x72, 0x65, 0x64, 0x73)
   908  	if err != nil {
   909  		return
   910  	}
   911  	// map header, size 3
   912  	// write "AccessKey"
   913  	err = en.Append(0x83, 0xa9, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4b, 0x65, 0x79)
   914  	if err != nil {
   915  		return
   916  	}
   917  	err = en.WriteString(z.Creds.AccessKey)
   918  	if err != nil {
   919  		err = msgp.WrapError(err, "Creds", "AccessKey")
   920  		return
   921  	}
   922  	// write "SecretKey"
   923  	err = en.Append(0xa9, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x4b, 0x65, 0x79)
   924  	if err != nil {
   925  		return
   926  	}
   927  	err = en.WriteString(z.Creds.SecretKey)
   928  	if err != nil {
   929  		err = msgp.WrapError(err, "Creds", "SecretKey")
   930  		return
   931  	}
   932  	// write "SessionToken"
   933  	err = en.Append(0xac, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x54, 0x6f, 0x6b, 0x65, 0x6e)
   934  	if err != nil {
   935  		return
   936  	}
   937  	err = en.WriteString(z.Creds.SessionToken)
   938  	if err != nil {
   939  		err = msgp.WrapError(err, "Creds", "SessionToken")
   940  		return
   941  	}
   942  	return
   943  }
   944  
   945  // MarshalMsg implements msgp.Marshaler
   946  func (z *BatchJobReplicateTarget) MarshalMsg(b []byte) (o []byte, err error) {
   947  	o = msgp.Require(b, z.Msgsize())
   948  	// map header, size 6
   949  	// string "Type"
   950  	o = append(o, 0x86, 0xa4, 0x54, 0x79, 0x70, 0x65)
   951  	o = msgp.AppendString(o, string(z.Type))
   952  	// string "Bucket"
   953  	o = append(o, 0xa6, 0x42, 0x75, 0x63, 0x6b, 0x65, 0x74)
   954  	o = msgp.AppendString(o, z.Bucket)
   955  	// string "Prefix"
   956  	o = append(o, 0xa6, 0x50, 0x72, 0x65, 0x66, 0x69, 0x78)
   957  	o = msgp.AppendString(o, z.Prefix)
   958  	// string "Endpoint"
   959  	o = append(o, 0xa8, 0x45, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74)
   960  	o = msgp.AppendString(o, z.Endpoint)
   961  	// string "Path"
   962  	o = append(o, 0xa4, 0x50, 0x61, 0x74, 0x68)
   963  	o = msgp.AppendString(o, z.Path)
   964  	// string "Creds"
   965  	o = append(o, 0xa5, 0x43, 0x72, 0x65, 0x64, 0x73)
   966  	// map header, size 3
   967  	// string "AccessKey"
   968  	o = append(o, 0x83, 0xa9, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x4b, 0x65, 0x79)
   969  	o = msgp.AppendString(o, z.Creds.AccessKey)
   970  	// string "SecretKey"
   971  	o = append(o, 0xa9, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x4b, 0x65, 0x79)
   972  	o = msgp.AppendString(o, z.Creds.SecretKey)
   973  	// string "SessionToken"
   974  	o = append(o, 0xac, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x54, 0x6f, 0x6b, 0x65, 0x6e)
   975  	o = msgp.AppendString(o, z.Creds.SessionToken)
   976  	return
   977  }
   978  
   979  // UnmarshalMsg implements msgp.Unmarshaler
   980  func (z *BatchJobReplicateTarget) UnmarshalMsg(bts []byte) (o []byte, err error) {
   981  	var field []byte
   982  	_ = field
   983  	var zb0001 uint32
   984  	zb0001, bts, err = msgp.ReadMapHeaderBytes(bts)
   985  	if err != nil {
   986  		err = msgp.WrapError(err)
   987  		return
   988  	}
   989  	for zb0001 > 0 {
   990  		zb0001--
   991  		field, bts, err = msgp.ReadMapKeyZC(bts)
   992  		if err != nil {
   993  			err = msgp.WrapError(err)
   994  			return
   995  		}
   996  		switch msgp.UnsafeString(field) {
   997  		case "Type":
   998  			{
   999  				var zb0002 string
  1000  				zb0002, bts, err = msgp.ReadStringBytes(bts)
  1001  				if err != nil {
  1002  					err = msgp.WrapError(err, "Type")
  1003  					return
  1004  				}
  1005  				z.Type = BatchJobReplicateResourceType(zb0002)
  1006  			}
  1007  		case "Bucket":
  1008  			z.Bucket, bts, err = msgp.ReadStringBytes(bts)
  1009  			if err != nil {
  1010  				err = msgp.WrapError(err, "Bucket")
  1011  				return
  1012  			}
  1013  		case "Prefix":
  1014  			z.Prefix, bts, err = msgp.ReadStringBytes(bts)
  1015  			if err != nil {
  1016  				err = msgp.WrapError(err, "Prefix")
  1017  				return
  1018  			}
  1019  		case "Endpoint":
  1020  			z.Endpoint, bts, err = msgp.ReadStringBytes(bts)
  1021  			if err != nil {
  1022  				err = msgp.WrapError(err, "Endpoint")
  1023  				return
  1024  			}
  1025  		case "Path":
  1026  			z.Path, bts, err = msgp.ReadStringBytes(bts)
  1027  			if err != nil {
  1028  				err = msgp.WrapError(err, "Path")
  1029  				return
  1030  			}
  1031  		case "Creds":
  1032  			var zb0003 uint32
  1033  			zb0003, bts, err = msgp.ReadMapHeaderBytes(bts)
  1034  			if err != nil {
  1035  				err = msgp.WrapError(err, "Creds")
  1036  				return
  1037  			}
  1038  			for zb0003 > 0 {
  1039  				zb0003--
  1040  				field, bts, err = msgp.ReadMapKeyZC(bts)
  1041  				if err != nil {
  1042  					err = msgp.WrapError(err, "Creds")
  1043  					return
  1044  				}
  1045  				switch msgp.UnsafeString(field) {
  1046  				case "AccessKey":
  1047  					z.Creds.AccessKey, bts, err = msgp.ReadStringBytes(bts)
  1048  					if err != nil {
  1049  						err = msgp.WrapError(err, "Creds", "AccessKey")
  1050  						return
  1051  					}
  1052  				case "SecretKey":
  1053  					z.Creds.SecretKey, bts, err = msgp.ReadStringBytes(bts)
  1054  					if err != nil {
  1055  						err = msgp.WrapError(err, "Creds", "SecretKey")
  1056  						return
  1057  					}
  1058  				case "SessionToken":
  1059  					z.Creds.SessionToken, bts, err = msgp.ReadStringBytes(bts)
  1060  					if err != nil {
  1061  						err = msgp.WrapError(err, "Creds", "SessionToken")
  1062  						return
  1063  					}
  1064  				default:
  1065  					bts, err = msgp.Skip(bts)
  1066  					if err != nil {
  1067  						err = msgp.WrapError(err, "Creds")
  1068  						return
  1069  					}
  1070  				}
  1071  			}
  1072  		default:
  1073  			bts, err = msgp.Skip(bts)
  1074  			if err != nil {
  1075  				err = msgp.WrapError(err)
  1076  				return
  1077  			}
  1078  		}
  1079  	}
  1080  	o = bts
  1081  	return
  1082  }
  1083  
  1084  // Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
  1085  func (z *BatchJobReplicateTarget) Msgsize() (s int) {
  1086  	s = 1 + 5 + msgp.StringPrefixSize + len(string(z.Type)) + 7 + msgp.StringPrefixSize + len(z.Bucket) + 7 + msgp.StringPrefixSize + len(z.Prefix) + 9 + msgp.StringPrefixSize + len(z.Endpoint) + 5 + msgp.StringPrefixSize + len(z.Path) + 6 + 1 + 10 + msgp.StringPrefixSize + len(z.Creds.AccessKey) + 10 + msgp.StringPrefixSize + len(z.Creds.SecretKey) + 13 + msgp.StringPrefixSize + len(z.Creds.SessionToken)
  1087  	return
  1088  }
  1089  
  1090  // DecodeMsg implements msgp.Decodable
  1091  func (z *BatchJobReplicateV1) DecodeMsg(dc *msgp.Reader) (err error) {
  1092  	var field []byte
  1093  	_ = field
  1094  	var zb0001 uint32
  1095  	zb0001, err = dc.ReadMapHeader()
  1096  	if err != nil {
  1097  		err = msgp.WrapError(err)
  1098  		return
  1099  	}
  1100  	for zb0001 > 0 {
  1101  		zb0001--
  1102  		field, err = dc.ReadMapKeyPtr()
  1103  		if err != nil {
  1104  			err = msgp.WrapError(err)
  1105  			return
  1106  		}
  1107  		switch msgp.UnsafeString(field) {
  1108  		case "APIVersion":
  1109  			z.APIVersion, err = dc.ReadString()
  1110  			if err != nil {
  1111  				err = msgp.WrapError(err, "APIVersion")
  1112  				return
  1113  			}
  1114  		case "Flags":
  1115  			var zb0002 uint32
  1116  			zb0002, err = dc.ReadMapHeader()
  1117  			if err != nil {
  1118  				err = msgp.WrapError(err, "Flags")
  1119  				return
  1120  			}
  1121  			for zb0002 > 0 {
  1122  				zb0002--
  1123  				field, err = dc.ReadMapKeyPtr()
  1124  				if err != nil {
  1125  					err = msgp.WrapError(err, "Flags")
  1126  					return
  1127  				}
  1128  				switch msgp.UnsafeString(field) {
  1129  				case "Filter":
  1130  					err = z.Flags.Filter.DecodeMsg(dc)
  1131  					if err != nil {
  1132  						err = msgp.WrapError(err, "Flags", "Filter")
  1133  						return
  1134  					}
  1135  				case "Notify":
  1136  					err = z.Flags.Notify.DecodeMsg(dc)
  1137  					if err != nil {
  1138  						err = msgp.WrapError(err, "Flags", "Notify")
  1139  						return
  1140  					}
  1141  				case "Retry":
  1142  					err = z.Flags.Retry.DecodeMsg(dc)
  1143  					if err != nil {
  1144  						err = msgp.WrapError(err, "Flags", "Retry")
  1145  						return
  1146  					}
  1147  				default:
  1148  					err = dc.Skip()
  1149  					if err != nil {
  1150  						err = msgp.WrapError(err, "Flags")
  1151  						return
  1152  					}
  1153  				}
  1154  			}
  1155  		case "Target":
  1156  			err = z.Target.DecodeMsg(dc)
  1157  			if err != nil {
  1158  				err = msgp.WrapError(err, "Target")
  1159  				return
  1160  			}
  1161  		case "Source":
  1162  			err = z.Source.DecodeMsg(dc)
  1163  			if err != nil {
  1164  				err = msgp.WrapError(err, "Source")
  1165  				return
  1166  			}
  1167  		default:
  1168  			err = dc.Skip()
  1169  			if err != nil {
  1170  				err = msgp.WrapError(err)
  1171  				return
  1172  			}
  1173  		}
  1174  	}
  1175  	return
  1176  }
  1177  
  1178  // EncodeMsg implements msgp.Encodable
  1179  func (z *BatchJobReplicateV1) EncodeMsg(en *msgp.Writer) (err error) {
  1180  	// map header, size 4
  1181  	// write "APIVersion"
  1182  	err = en.Append(0x84, 0xaa, 0x41, 0x50, 0x49, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e)
  1183  	if err != nil {
  1184  		return
  1185  	}
  1186  	err = en.WriteString(z.APIVersion)
  1187  	if err != nil {
  1188  		err = msgp.WrapError(err, "APIVersion")
  1189  		return
  1190  	}
  1191  	// write "Flags"
  1192  	err = en.Append(0xa5, 0x46, 0x6c, 0x61, 0x67, 0x73)
  1193  	if err != nil {
  1194  		return
  1195  	}
  1196  	// map header, size 3
  1197  	// write "Filter"
  1198  	err = en.Append(0x83, 0xa6, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72)
  1199  	if err != nil {
  1200  		return
  1201  	}
  1202  	err = z.Flags.Filter.EncodeMsg(en)
  1203  	if err != nil {
  1204  		err = msgp.WrapError(err, "Flags", "Filter")
  1205  		return
  1206  	}
  1207  	// write "Notify"
  1208  	err = en.Append(0xa6, 0x4e, 0x6f, 0x74, 0x69, 0x66, 0x79)
  1209  	if err != nil {
  1210  		return
  1211  	}
  1212  	err = z.Flags.Notify.EncodeMsg(en)
  1213  	if err != nil {
  1214  		err = msgp.WrapError(err, "Flags", "Notify")
  1215  		return
  1216  	}
  1217  	// write "Retry"
  1218  	err = en.Append(0xa5, 0x52, 0x65, 0x74, 0x72, 0x79)
  1219  	if err != nil {
  1220  		return
  1221  	}
  1222  	err = z.Flags.Retry.EncodeMsg(en)
  1223  	if err != nil {
  1224  		err = msgp.WrapError(err, "Flags", "Retry")
  1225  		return
  1226  	}
  1227  	// write "Target"
  1228  	err = en.Append(0xa6, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74)
  1229  	if err != nil {
  1230  		return
  1231  	}
  1232  	err = z.Target.EncodeMsg(en)
  1233  	if err != nil {
  1234  		err = msgp.WrapError(err, "Target")
  1235  		return
  1236  	}
  1237  	// write "Source"
  1238  	err = en.Append(0xa6, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65)
  1239  	if err != nil {
  1240  		return
  1241  	}
  1242  	err = z.Source.EncodeMsg(en)
  1243  	if err != nil {
  1244  		err = msgp.WrapError(err, "Source")
  1245  		return
  1246  	}
  1247  	return
  1248  }
  1249  
  1250  // MarshalMsg implements msgp.Marshaler
  1251  func (z *BatchJobReplicateV1) MarshalMsg(b []byte) (o []byte, err error) {
  1252  	o = msgp.Require(b, z.Msgsize())
  1253  	// map header, size 4
  1254  	// string "APIVersion"
  1255  	o = append(o, 0x84, 0xaa, 0x41, 0x50, 0x49, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e)
  1256  	o = msgp.AppendString(o, z.APIVersion)
  1257  	// string "Flags"
  1258  	o = append(o, 0xa5, 0x46, 0x6c, 0x61, 0x67, 0x73)
  1259  	// map header, size 3
  1260  	// string "Filter"
  1261  	o = append(o, 0x83, 0xa6, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72)
  1262  	o, err = z.Flags.Filter.MarshalMsg(o)
  1263  	if err != nil {
  1264  		err = msgp.WrapError(err, "Flags", "Filter")
  1265  		return
  1266  	}
  1267  	// string "Notify"
  1268  	o = append(o, 0xa6, 0x4e, 0x6f, 0x74, 0x69, 0x66, 0x79)
  1269  	o, err = z.Flags.Notify.MarshalMsg(o)
  1270  	if err != nil {
  1271  		err = msgp.WrapError(err, "Flags", "Notify")
  1272  		return
  1273  	}
  1274  	// string "Retry"
  1275  	o = append(o, 0xa5, 0x52, 0x65, 0x74, 0x72, 0x79)
  1276  	o, err = z.Flags.Retry.MarshalMsg(o)
  1277  	if err != nil {
  1278  		err = msgp.WrapError(err, "Flags", "Retry")
  1279  		return
  1280  	}
  1281  	// string "Target"
  1282  	o = append(o, 0xa6, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74)
  1283  	o, err = z.Target.MarshalMsg(o)
  1284  	if err != nil {
  1285  		err = msgp.WrapError(err, "Target")
  1286  		return
  1287  	}
  1288  	// string "Source"
  1289  	o = append(o, 0xa6, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65)
  1290  	o, err = z.Source.MarshalMsg(o)
  1291  	if err != nil {
  1292  		err = msgp.WrapError(err, "Source")
  1293  		return
  1294  	}
  1295  	return
  1296  }
  1297  
  1298  // UnmarshalMsg implements msgp.Unmarshaler
  1299  func (z *BatchJobReplicateV1) UnmarshalMsg(bts []byte) (o []byte, err error) {
  1300  	var field []byte
  1301  	_ = field
  1302  	var zb0001 uint32
  1303  	zb0001, bts, err = msgp.ReadMapHeaderBytes(bts)
  1304  	if err != nil {
  1305  		err = msgp.WrapError(err)
  1306  		return
  1307  	}
  1308  	for zb0001 > 0 {
  1309  		zb0001--
  1310  		field, bts, err = msgp.ReadMapKeyZC(bts)
  1311  		if err != nil {
  1312  			err = msgp.WrapError(err)
  1313  			return
  1314  		}
  1315  		switch msgp.UnsafeString(field) {
  1316  		case "APIVersion":
  1317  			z.APIVersion, bts, err = msgp.ReadStringBytes(bts)
  1318  			if err != nil {
  1319  				err = msgp.WrapError(err, "APIVersion")
  1320  				return
  1321  			}
  1322  		case "Flags":
  1323  			var zb0002 uint32
  1324  			zb0002, bts, err = msgp.ReadMapHeaderBytes(bts)
  1325  			if err != nil {
  1326  				err = msgp.WrapError(err, "Flags")
  1327  				return
  1328  			}
  1329  			for zb0002 > 0 {
  1330  				zb0002--
  1331  				field, bts, err = msgp.ReadMapKeyZC(bts)
  1332  				if err != nil {
  1333  					err = msgp.WrapError(err, "Flags")
  1334  					return
  1335  				}
  1336  				switch msgp.UnsafeString(field) {
  1337  				case "Filter":
  1338  					bts, err = z.Flags.Filter.UnmarshalMsg(bts)
  1339  					if err != nil {
  1340  						err = msgp.WrapError(err, "Flags", "Filter")
  1341  						return
  1342  					}
  1343  				case "Notify":
  1344  					bts, err = z.Flags.Notify.UnmarshalMsg(bts)
  1345  					if err != nil {
  1346  						err = msgp.WrapError(err, "Flags", "Notify")
  1347  						return
  1348  					}
  1349  				case "Retry":
  1350  					bts, err = z.Flags.Retry.UnmarshalMsg(bts)
  1351  					if err != nil {
  1352  						err = msgp.WrapError(err, "Flags", "Retry")
  1353  						return
  1354  					}
  1355  				default:
  1356  					bts, err = msgp.Skip(bts)
  1357  					if err != nil {
  1358  						err = msgp.WrapError(err, "Flags")
  1359  						return
  1360  					}
  1361  				}
  1362  			}
  1363  		case "Target":
  1364  			bts, err = z.Target.UnmarshalMsg(bts)
  1365  			if err != nil {
  1366  				err = msgp.WrapError(err, "Target")
  1367  				return
  1368  			}
  1369  		case "Source":
  1370  			bts, err = z.Source.UnmarshalMsg(bts)
  1371  			if err != nil {
  1372  				err = msgp.WrapError(err, "Source")
  1373  				return
  1374  			}
  1375  		default:
  1376  			bts, err = msgp.Skip(bts)
  1377  			if err != nil {
  1378  				err = msgp.WrapError(err)
  1379  				return
  1380  			}
  1381  		}
  1382  	}
  1383  	o = bts
  1384  	return
  1385  }
  1386  
  1387  // Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
  1388  func (z *BatchJobReplicateV1) Msgsize() (s int) {
  1389  	s = 1 + 11 + msgp.StringPrefixSize + len(z.APIVersion) + 6 + 1 + 7 + z.Flags.Filter.Msgsize() + 7 + z.Flags.Notify.Msgsize() + 6 + z.Flags.Retry.Msgsize() + 7 + z.Target.Msgsize() + 7 + z.Source.Msgsize()
  1390  	return
  1391  }
  1392  
  1393  // DecodeMsg implements msgp.Decodable
  1394  func (z *BatchReplicateFilter) DecodeMsg(dc *msgp.Reader) (err error) {
  1395  	var field []byte
  1396  	_ = field
  1397  	var zb0001 uint32
  1398  	zb0001, err = dc.ReadMapHeader()
  1399  	if err != nil {
  1400  		err = msgp.WrapError(err)
  1401  		return
  1402  	}
  1403  	for zb0001 > 0 {
  1404  		zb0001--
  1405  		field, err = dc.ReadMapKeyPtr()
  1406  		if err != nil {
  1407  			err = msgp.WrapError(err)
  1408  			return
  1409  		}
  1410  		switch msgp.UnsafeString(field) {
  1411  		case "NewerThan":
  1412  			z.NewerThan, err = dc.ReadDuration()
  1413  			if err != nil {
  1414  				err = msgp.WrapError(err, "NewerThan")
  1415  				return
  1416  			}
  1417  		case "OlderThan":
  1418  			z.OlderThan, err = dc.ReadDuration()
  1419  			if err != nil {
  1420  				err = msgp.WrapError(err, "OlderThan")
  1421  				return
  1422  			}
  1423  		case "CreatedAfter":
  1424  			z.CreatedAfter, err = dc.ReadTime()
  1425  			if err != nil {
  1426  				err = msgp.WrapError(err, "CreatedAfter")
  1427  				return
  1428  			}
  1429  		case "CreatedBefore":
  1430  			z.CreatedBefore, err = dc.ReadTime()
  1431  			if err != nil {
  1432  				err = msgp.WrapError(err, "CreatedBefore")
  1433  				return
  1434  			}
  1435  		case "Tags":
  1436  			var zb0002 uint32
  1437  			zb0002, err = dc.ReadArrayHeader()
  1438  			if err != nil {
  1439  				err = msgp.WrapError(err, "Tags")
  1440  				return
  1441  			}
  1442  			if cap(z.Tags) >= int(zb0002) {
  1443  				z.Tags = (z.Tags)[:zb0002]
  1444  			} else {
  1445  				z.Tags = make([]BatchJobKV, zb0002)
  1446  			}
  1447  			for za0001 := range z.Tags {
  1448  				err = z.Tags[za0001].DecodeMsg(dc)
  1449  				if err != nil {
  1450  					err = msgp.WrapError(err, "Tags", za0001)
  1451  					return
  1452  				}
  1453  			}
  1454  		case "Metadata":
  1455  			var zb0003 uint32
  1456  			zb0003, err = dc.ReadArrayHeader()
  1457  			if err != nil {
  1458  				err = msgp.WrapError(err, "Metadata")
  1459  				return
  1460  			}
  1461  			if cap(z.Metadata) >= int(zb0003) {
  1462  				z.Metadata = (z.Metadata)[:zb0003]
  1463  			} else {
  1464  				z.Metadata = make([]BatchJobKV, zb0003)
  1465  			}
  1466  			for za0002 := range z.Metadata {
  1467  				err = z.Metadata[za0002].DecodeMsg(dc)
  1468  				if err != nil {
  1469  					err = msgp.WrapError(err, "Metadata", za0002)
  1470  					return
  1471  				}
  1472  			}
  1473  		default:
  1474  			err = dc.Skip()
  1475  			if err != nil {
  1476  				err = msgp.WrapError(err)
  1477  				return
  1478  			}
  1479  		}
  1480  	}
  1481  	return
  1482  }
  1483  
  1484  // EncodeMsg implements msgp.Encodable
  1485  func (z *BatchReplicateFilter) EncodeMsg(en *msgp.Writer) (err error) {
  1486  	// map header, size 6
  1487  	// write "NewerThan"
  1488  	err = en.Append(0x86, 0xa9, 0x4e, 0x65, 0x77, 0x65, 0x72, 0x54, 0x68, 0x61, 0x6e)
  1489  	if err != nil {
  1490  		return
  1491  	}
  1492  	err = en.WriteDuration(z.NewerThan)
  1493  	if err != nil {
  1494  		err = msgp.WrapError(err, "NewerThan")
  1495  		return
  1496  	}
  1497  	// write "OlderThan"
  1498  	err = en.Append(0xa9, 0x4f, 0x6c, 0x64, 0x65, 0x72, 0x54, 0x68, 0x61, 0x6e)
  1499  	if err != nil {
  1500  		return
  1501  	}
  1502  	err = en.WriteDuration(z.OlderThan)
  1503  	if err != nil {
  1504  		err = msgp.WrapError(err, "OlderThan")
  1505  		return
  1506  	}
  1507  	// write "CreatedAfter"
  1508  	err = en.Append(0xac, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x41, 0x66, 0x74, 0x65, 0x72)
  1509  	if err != nil {
  1510  		return
  1511  	}
  1512  	err = en.WriteTime(z.CreatedAfter)
  1513  	if err != nil {
  1514  		err = msgp.WrapError(err, "CreatedAfter")
  1515  		return
  1516  	}
  1517  	// write "CreatedBefore"
  1518  	err = en.Append(0xad, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x42, 0x65, 0x66, 0x6f, 0x72, 0x65)
  1519  	if err != nil {
  1520  		return
  1521  	}
  1522  	err = en.WriteTime(z.CreatedBefore)
  1523  	if err != nil {
  1524  		err = msgp.WrapError(err, "CreatedBefore")
  1525  		return
  1526  	}
  1527  	// write "Tags"
  1528  	err = en.Append(0xa4, 0x54, 0x61, 0x67, 0x73)
  1529  	if err != nil {
  1530  		return
  1531  	}
  1532  	err = en.WriteArrayHeader(uint32(len(z.Tags)))
  1533  	if err != nil {
  1534  		err = msgp.WrapError(err, "Tags")
  1535  		return
  1536  	}
  1537  	for za0001 := range z.Tags {
  1538  		err = z.Tags[za0001].EncodeMsg(en)
  1539  		if err != nil {
  1540  			err = msgp.WrapError(err, "Tags", za0001)
  1541  			return
  1542  		}
  1543  	}
  1544  	// write "Metadata"
  1545  	err = en.Append(0xa8, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61)
  1546  	if err != nil {
  1547  		return
  1548  	}
  1549  	err = en.WriteArrayHeader(uint32(len(z.Metadata)))
  1550  	if err != nil {
  1551  		err = msgp.WrapError(err, "Metadata")
  1552  		return
  1553  	}
  1554  	for za0002 := range z.Metadata {
  1555  		err = z.Metadata[za0002].EncodeMsg(en)
  1556  		if err != nil {
  1557  			err = msgp.WrapError(err, "Metadata", za0002)
  1558  			return
  1559  		}
  1560  	}
  1561  	return
  1562  }
  1563  
  1564  // MarshalMsg implements msgp.Marshaler
  1565  func (z *BatchReplicateFilter) MarshalMsg(b []byte) (o []byte, err error) {
  1566  	o = msgp.Require(b, z.Msgsize())
  1567  	// map header, size 6
  1568  	// string "NewerThan"
  1569  	o = append(o, 0x86, 0xa9, 0x4e, 0x65, 0x77, 0x65, 0x72, 0x54, 0x68, 0x61, 0x6e)
  1570  	o = msgp.AppendDuration(o, z.NewerThan)
  1571  	// string "OlderThan"
  1572  	o = append(o, 0xa9, 0x4f, 0x6c, 0x64, 0x65, 0x72, 0x54, 0x68, 0x61, 0x6e)
  1573  	o = msgp.AppendDuration(o, z.OlderThan)
  1574  	// string "CreatedAfter"
  1575  	o = append(o, 0xac, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x41, 0x66, 0x74, 0x65, 0x72)
  1576  	o = msgp.AppendTime(o, z.CreatedAfter)
  1577  	// string "CreatedBefore"
  1578  	o = append(o, 0xad, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x42, 0x65, 0x66, 0x6f, 0x72, 0x65)
  1579  	o = msgp.AppendTime(o, z.CreatedBefore)
  1580  	// string "Tags"
  1581  	o = append(o, 0xa4, 0x54, 0x61, 0x67, 0x73)
  1582  	o = msgp.AppendArrayHeader(o, uint32(len(z.Tags)))
  1583  	for za0001 := range z.Tags {
  1584  		o, err = z.Tags[za0001].MarshalMsg(o)
  1585  		if err != nil {
  1586  			err = msgp.WrapError(err, "Tags", za0001)
  1587  			return
  1588  		}
  1589  	}
  1590  	// string "Metadata"
  1591  	o = append(o, 0xa8, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61)
  1592  	o = msgp.AppendArrayHeader(o, uint32(len(z.Metadata)))
  1593  	for za0002 := range z.Metadata {
  1594  		o, err = z.Metadata[za0002].MarshalMsg(o)
  1595  		if err != nil {
  1596  			err = msgp.WrapError(err, "Metadata", za0002)
  1597  			return
  1598  		}
  1599  	}
  1600  	return
  1601  }
  1602  
  1603  // UnmarshalMsg implements msgp.Unmarshaler
  1604  func (z *BatchReplicateFilter) UnmarshalMsg(bts []byte) (o []byte, err error) {
  1605  	var field []byte
  1606  	_ = field
  1607  	var zb0001 uint32
  1608  	zb0001, bts, err = msgp.ReadMapHeaderBytes(bts)
  1609  	if err != nil {
  1610  		err = msgp.WrapError(err)
  1611  		return
  1612  	}
  1613  	for zb0001 > 0 {
  1614  		zb0001--
  1615  		field, bts, err = msgp.ReadMapKeyZC(bts)
  1616  		if err != nil {
  1617  			err = msgp.WrapError(err)
  1618  			return
  1619  		}
  1620  		switch msgp.UnsafeString(field) {
  1621  		case "NewerThan":
  1622  			z.NewerThan, bts, err = msgp.ReadDurationBytes(bts)
  1623  			if err != nil {
  1624  				err = msgp.WrapError(err, "NewerThan")
  1625  				return
  1626  			}
  1627  		case "OlderThan":
  1628  			z.OlderThan, bts, err = msgp.ReadDurationBytes(bts)
  1629  			if err != nil {
  1630  				err = msgp.WrapError(err, "OlderThan")
  1631  				return
  1632  			}
  1633  		case "CreatedAfter":
  1634  			z.CreatedAfter, bts, err = msgp.ReadTimeBytes(bts)
  1635  			if err != nil {
  1636  				err = msgp.WrapError(err, "CreatedAfter")
  1637  				return
  1638  			}
  1639  		case "CreatedBefore":
  1640  			z.CreatedBefore, bts, err = msgp.ReadTimeBytes(bts)
  1641  			if err != nil {
  1642  				err = msgp.WrapError(err, "CreatedBefore")
  1643  				return
  1644  			}
  1645  		case "Tags":
  1646  			var zb0002 uint32
  1647  			zb0002, bts, err = msgp.ReadArrayHeaderBytes(bts)
  1648  			if err != nil {
  1649  				err = msgp.WrapError(err, "Tags")
  1650  				return
  1651  			}
  1652  			if cap(z.Tags) >= int(zb0002) {
  1653  				z.Tags = (z.Tags)[:zb0002]
  1654  			} else {
  1655  				z.Tags = make([]BatchJobKV, zb0002)
  1656  			}
  1657  			for za0001 := range z.Tags {
  1658  				bts, err = z.Tags[za0001].UnmarshalMsg(bts)
  1659  				if err != nil {
  1660  					err = msgp.WrapError(err, "Tags", za0001)
  1661  					return
  1662  				}
  1663  			}
  1664  		case "Metadata":
  1665  			var zb0003 uint32
  1666  			zb0003, bts, err = msgp.ReadArrayHeaderBytes(bts)
  1667  			if err != nil {
  1668  				err = msgp.WrapError(err, "Metadata")
  1669  				return
  1670  			}
  1671  			if cap(z.Metadata) >= int(zb0003) {
  1672  				z.Metadata = (z.Metadata)[:zb0003]
  1673  			} else {
  1674  				z.Metadata = make([]BatchJobKV, zb0003)
  1675  			}
  1676  			for za0002 := range z.Metadata {
  1677  				bts, err = z.Metadata[za0002].UnmarshalMsg(bts)
  1678  				if err != nil {
  1679  					err = msgp.WrapError(err, "Metadata", za0002)
  1680  					return
  1681  				}
  1682  			}
  1683  		default:
  1684  			bts, err = msgp.Skip(bts)
  1685  			if err != nil {
  1686  				err = msgp.WrapError(err)
  1687  				return
  1688  			}
  1689  		}
  1690  	}
  1691  	o = bts
  1692  	return
  1693  }
  1694  
  1695  // Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
  1696  func (z *BatchReplicateFilter) Msgsize() (s int) {
  1697  	s = 1 + 10 + msgp.DurationSize + 10 + msgp.DurationSize + 13 + msgp.TimeSize + 14 + msgp.TimeSize + 5 + msgp.ArrayHeaderSize
  1698  	for za0001 := range z.Tags {
  1699  		s += z.Tags[za0001].Msgsize()
  1700  	}
  1701  	s += 9 + msgp.ArrayHeaderSize
  1702  	for za0002 := range z.Metadata {
  1703  		s += z.Metadata[za0002].Msgsize()
  1704  	}
  1705  	return
  1706  }