bump to sbt-contraband 0.3.0-M7 and latest util

2017-07-01 19:27:54 -04:00 · 2017-07-01 19:27:54 -04:00 · 4ac724e529
parent e8d5bcc600
commit 4ac724e529
115 changed files with 4191 additions and 8 deletions
--- a/build.sbt
+++ b/build.sbt
@ -69,7 +69,7 @@ lazy val lm = (project in file("librarymanagement"))
                                launcherInterface,
                                gigahorseOkhttp,
                                okhttpUrlconnection,
-                                sjsonnewScalaJson % Optional),
+                                sjsonnewScalaJson.value % Optional),
    libraryDependencies ++= scalaXml.value,
    resourceGenerators in Compile += Def
      .task(
@ -79,6 +79,9 @@ lazy val lm = (project in file("librarymanagement"))
                                 (compile in Compile).value))
      .taskValue,
    // mimaBinaryIssueFilters ++= Seq(),
+    managedSourceDirectories in Compile +=
+      baseDirectory.value / "src" / "main" / "contraband-scala",
+    sourceManaged in (Compile, generateContrabands) := baseDirectory.value / "src" / "main" / "contraband-scala",
    contrabandFormatsForType in generateContrabands in Compile := DatatypeConfig.getFormats,
    // WORKAROUND sbt/sbt#2205 include managed sources in packageSrc
    mappings in (Compile, packageSrc) ++= {
--- a/librarymanagement/src/main/contraband-scala/sbt/internal/librarymanagement/ConfigurationReportLite.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/internal/librarymanagement/ConfigurationReportLite.scala
@ -0,0 +1,36 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.librarymanagement
+final class ConfigurationReportLite private (
+  val configuration: String,
+  val details: Vector[sbt.librarymanagement.OrganizationArtifactReport]) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = o match {
+    case x: ConfigurationReportLite => (this.configuration == x.configuration) && (this.details == x.details)
+    case _ => false
+  }
+  override def hashCode: Int = {
+    37 * (37 * (37 * (17 + "ConfigurationReportLite".##) + configuration.##) + details.##)
+  }
+  override def toString: String = {
+    "ConfigurationReportLite(" + configuration + ", " + details + ")"
+  }
+  protected[this] def copy(configuration: String = configuration, details: Vector[sbt.librarymanagement.OrganizationArtifactReport] = details): ConfigurationReportLite = {
+    new ConfigurationReportLite(configuration, details)
+  }
+  def withConfiguration(configuration: String): ConfigurationReportLite = {
+    copy(configuration = configuration)
+  }
+  def withDetails(details: Vector[sbt.librarymanagement.OrganizationArtifactReport]): ConfigurationReportLite = {
+    copy(details = details)
+  }
+}
+object ConfigurationReportLite {
+  
+  def apply(configuration: String, details: Vector[sbt.librarymanagement.OrganizationArtifactReport]): ConfigurationReportLite = new ConfigurationReportLite(configuration, details)
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/internal/librarymanagement/ExternalIvyConfiguration.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/internal/librarymanagement/ExternalIvyConfiguration.scala
@ -0,0 +1,56 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.librarymanagement
+final class ExternalIvyConfiguration private (
+  lock: Option[xsbti.GlobalLock],
+  baseDirectory: java.io.File,
+  log: xsbti.Logger,
+  updateOptions: sbt.librarymanagement.UpdateOptions,
+  val uri: java.net.URI,
+  val extraResolvers: Vector[sbt.librarymanagement.Resolver]) extends sbt.internal.librarymanagement.IvyConfiguration(lock, baseDirectory, log, updateOptions) with Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = o match {
+    case x: ExternalIvyConfiguration => (this.lock == x.lock) && (this.baseDirectory == x.baseDirectory) && (this.log == x.log) && (this.updateOptions == x.updateOptions) && (this.uri == x.uri) && (this.extraResolvers == x.extraResolvers)
+    case _ => false
+  }
+  override def hashCode: Int = {
+    37 * (37 * (37 * (37 * (37 * (37 * (37 * (17 + "ExternalIvyConfiguration".##) + lock.##) + baseDirectory.##) + log.##) + updateOptions.##) + uri.##) + extraResolvers.##)
+  }
+  override def toString: String = {
+    "ExternalIvyConfiguration(" + lock + ", " + baseDirectory + ", " + log + ", " + updateOptions + ", " + uri + ", " + extraResolvers + ")"
+  }
+  protected[this] def copy(lock: Option[xsbti.GlobalLock] = lock, baseDirectory: java.io.File = baseDirectory, log: xsbti.Logger = log, updateOptions: sbt.librarymanagement.UpdateOptions = updateOptions, uri: java.net.URI = uri, extraResolvers: Vector[sbt.librarymanagement.Resolver] = extraResolvers): ExternalIvyConfiguration = {
+    new ExternalIvyConfiguration(lock, baseDirectory, log, updateOptions, uri, extraResolvers)
+  }
+  def withLock(lock: Option[xsbti.GlobalLock]): ExternalIvyConfiguration = {
+    copy(lock = lock)
+  }
+  def withLock(lock: xsbti.GlobalLock): ExternalIvyConfiguration = {
+    copy(lock = Option(lock))
+  }
+  def withBaseDirectory(baseDirectory: java.io.File): ExternalIvyConfiguration = {
+    copy(baseDirectory = baseDirectory)
+  }
+  def withLog(log: xsbti.Logger): ExternalIvyConfiguration = {
+    copy(log = log)
+  }
+  def withUpdateOptions(updateOptions: sbt.librarymanagement.UpdateOptions): ExternalIvyConfiguration = {
+    copy(updateOptions = updateOptions)
+  }
+  def withUri(uri: java.net.URI): ExternalIvyConfiguration = {
+    copy(uri = uri)
+  }
+  def withExtraResolvers(extraResolvers: Vector[sbt.librarymanagement.Resolver]): ExternalIvyConfiguration = {
+    copy(extraResolvers = extraResolvers)
+  }
+}
+object ExternalIvyConfiguration {
+  
+  def apply(lock: Option[xsbti.GlobalLock], baseDirectory: java.io.File, log: xsbti.Logger, updateOptions: sbt.librarymanagement.UpdateOptions, uri: java.net.URI, extraResolvers: Vector[sbt.librarymanagement.Resolver]): ExternalIvyConfiguration = new ExternalIvyConfiguration(lock, baseDirectory, log, updateOptions, uri, extraResolvers)
+  def apply(lock: xsbti.GlobalLock, baseDirectory: java.io.File, log: xsbti.Logger, updateOptions: sbt.librarymanagement.UpdateOptions, uri: java.net.URI, extraResolvers: Vector[sbt.librarymanagement.Resolver]): ExternalIvyConfiguration = new ExternalIvyConfiguration(Option(lock), baseDirectory, log, updateOptions, uri, extraResolvers)
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/internal/librarymanagement/InlineConfiguration.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/internal/librarymanagement/InlineConfiguration.scala
@ -0,0 +1,78 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.librarymanagement
+final class InlineConfiguration private (
+  validate: Boolean,
+  ivyScala: Option[sbt.librarymanagement.IvyScala],
+  val module: sbt.librarymanagement.ModuleID,
+  val moduleInfo: sbt.librarymanagement.ModuleInfo,
+  val dependencies: Vector[sbt.librarymanagement.ModuleID],
+  val overrides: Set[sbt.librarymanagement.ModuleID],
+  val excludes: Vector[sbt.librarymanagement.InclExclRule],
+  val ivyXML: scala.xml.NodeSeq,
+  val configurations: Vector[sbt.librarymanagement.Configuration],
+  val defaultConfiguration: Option[sbt.librarymanagement.Configuration],
+  val conflictManager: sbt.librarymanagement.ConflictManager) extends sbt.librarymanagement.ModuleSettings(validate, ivyScala) with Serializable {
+  
+  private def this(validate: Boolean, ivyScala: Option[sbt.librarymanagement.IvyScala], module: sbt.librarymanagement.ModuleID, moduleInfo: sbt.librarymanagement.ModuleInfo, dependencies: Vector[sbt.librarymanagement.ModuleID]) = this(validate, ivyScala, module, moduleInfo, dependencies, Set.empty, Vector.empty, scala.xml.NodeSeq.Empty, Vector.empty, None, sbt.librarymanagement.ConflictManager.default)
+  
+  override def equals(o: Any): Boolean = o match {
+    case x: InlineConfiguration => (this.validate == x.validate) && (this.ivyScala == x.ivyScala) && (this.module == x.module) && (this.moduleInfo == x.moduleInfo) && (this.dependencies == x.dependencies) && (this.overrides == x.overrides) && (this.excludes == x.excludes) && (this.ivyXML == x.ivyXML) && (this.configurations == x.configurations) && (this.defaultConfiguration == x.defaultConfiguration) && (this.conflictManager == x.conflictManager)
+    case _ => false
+  }
+  override def hashCode: Int = {
+    37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (17 + "InlineConfiguration".##) + validate.##) + ivyScala.##) + module.##) + moduleInfo.##) + dependencies.##) + overrides.##) + excludes.##) + ivyXML.##) + configurations.##) + defaultConfiguration.##) + conflictManager.##)
+  }
+  override def toString: String = {
+    "InlineConfiguration(" + validate + ", " + ivyScala + ", " + module + ", " + moduleInfo + ", " + dependencies + ", " + overrides + ", " + excludes + ", " + ivyXML + ", " + configurations + ", " + defaultConfiguration + ", " + conflictManager + ")"
+  }
+  protected[this] def copy(validate: Boolean = validate, ivyScala: Option[sbt.librarymanagement.IvyScala] = ivyScala, module: sbt.librarymanagement.ModuleID = module, moduleInfo: sbt.librarymanagement.ModuleInfo = moduleInfo, dependencies: Vector[sbt.librarymanagement.ModuleID] = dependencies, overrides: Set[sbt.librarymanagement.ModuleID] = overrides, excludes: Vector[sbt.librarymanagement.InclExclRule] = excludes, ivyXML: scala.xml.NodeSeq = ivyXML, configurations: Vector[sbt.librarymanagement.Configuration] = configurations, defaultConfiguration: Option[sbt.librarymanagement.Configuration] = defaultConfiguration, conflictManager: sbt.librarymanagement.ConflictManager = conflictManager): InlineConfiguration = {
+    new InlineConfiguration(validate, ivyScala, module, moduleInfo, dependencies, overrides, excludes, ivyXML, configurations, defaultConfiguration, conflictManager)
+  }
+  def withValidate(validate: Boolean): InlineConfiguration = {
+    copy(validate = validate)
+  }
+  def withIvyScala(ivyScala: Option[sbt.librarymanagement.IvyScala]): InlineConfiguration = {
+    copy(ivyScala = ivyScala)
+  }
+  def withIvyScala(ivyScala: sbt.librarymanagement.IvyScala): InlineConfiguration = {
+    copy(ivyScala = Option(ivyScala))
+  }
+  def withModule(module: sbt.librarymanagement.ModuleID): InlineConfiguration = {
+    copy(module = module)
+  }
+  def withModuleInfo(moduleInfo: sbt.librarymanagement.ModuleInfo): InlineConfiguration = {
+    copy(moduleInfo = moduleInfo)
+  }
+  def withDependencies(dependencies: Vector[sbt.librarymanagement.ModuleID]): InlineConfiguration = {
+    copy(dependencies = dependencies)
+  }
+  def withOverrides(overrides: Set[sbt.librarymanagement.ModuleID]): InlineConfiguration = {
+    copy(overrides = overrides)
+  }
+  def withExcludes(excludes: Vector[sbt.librarymanagement.InclExclRule]): InlineConfiguration = {
+    copy(excludes = excludes)
+  }
+  def withIvyXML(ivyXML: scala.xml.NodeSeq): InlineConfiguration = {
+    copy(ivyXML = ivyXML)
+  }
+  def withConfigurations(configurations: Vector[sbt.librarymanagement.Configuration]): InlineConfiguration = {
+    copy(configurations = configurations)
+  }
+  def withDefaultConfiguration(defaultConfiguration: Option[sbt.librarymanagement.Configuration]): InlineConfiguration = {
+    copy(defaultConfiguration = defaultConfiguration)
+  }
+  def withConflictManager(conflictManager: sbt.librarymanagement.ConflictManager): InlineConfiguration = {
+    copy(conflictManager = conflictManager)
+  }
+}
+object InlineConfiguration extends sbt.internal.librarymanagement.InlineConfigurationFunctions {
+  
+  def apply(validate: Boolean, ivyScala: Option[sbt.librarymanagement.IvyScala], module: sbt.librarymanagement.ModuleID, moduleInfo: sbt.librarymanagement.ModuleInfo, dependencies: Vector[sbt.librarymanagement.ModuleID]): InlineConfiguration = new InlineConfiguration(validate, ivyScala, module, moduleInfo, dependencies, Set.empty, Vector.empty, scala.xml.NodeSeq.Empty, Vector.empty, None, sbt.librarymanagement.ConflictManager.default)
+  def apply(validate: Boolean, ivyScala: sbt.librarymanagement.IvyScala, module: sbt.librarymanagement.ModuleID, moduleInfo: sbt.librarymanagement.ModuleInfo, dependencies: Vector[sbt.librarymanagement.ModuleID]): InlineConfiguration = new InlineConfiguration(validate, Option(ivyScala), module, moduleInfo, dependencies, Set.empty, Vector.empty, scala.xml.NodeSeq.Empty, Vector.empty, None, sbt.librarymanagement.ConflictManager.default)
+  def apply(validate: Boolean, ivyScala: Option[sbt.librarymanagement.IvyScala], module: sbt.librarymanagement.ModuleID, moduleInfo: sbt.librarymanagement.ModuleInfo, dependencies: Vector[sbt.librarymanagement.ModuleID], overrides: Set[sbt.librarymanagement.ModuleID], excludes: Vector[sbt.librarymanagement.InclExclRule], ivyXML: scala.xml.NodeSeq, configurations: Vector[sbt.librarymanagement.Configuration], defaultConfiguration: Option[sbt.librarymanagement.Configuration], conflictManager: sbt.librarymanagement.ConflictManager): InlineConfiguration = new InlineConfiguration(validate, ivyScala, module, moduleInfo, dependencies, overrides, excludes, ivyXML, configurations, defaultConfiguration, conflictManager)
+  def apply(validate: Boolean, ivyScala: sbt.librarymanagement.IvyScala, module: sbt.librarymanagement.ModuleID, moduleInfo: sbt.librarymanagement.ModuleInfo, dependencies: Vector[sbt.librarymanagement.ModuleID], overrides: Set[sbt.librarymanagement.ModuleID], excludes: Vector[sbt.librarymanagement.InclExclRule], ivyXML: scala.xml.NodeSeq, configurations: Vector[sbt.librarymanagement.Configuration], defaultConfiguration: Option[sbt.librarymanagement.Configuration], conflictManager: sbt.librarymanagement.ConflictManager): InlineConfiguration = new InlineConfiguration(validate, Option(ivyScala), module, moduleInfo, dependencies, overrides, excludes, ivyXML, configurations, defaultConfiguration, conflictManager)
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/internal/librarymanagement/InlineIvyConfiguration.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/internal/librarymanagement/InlineIvyConfiguration.scala
@ -0,0 +1,92 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.librarymanagement
+final class InlineIvyConfiguration private (
+  lock: Option[xsbti.GlobalLock],
+  baseDirectory: java.io.File,
+  log: xsbti.Logger,
+  updateOptions: sbt.librarymanagement.UpdateOptions,
+  val paths: sbt.internal.librarymanagement.IvyPaths,
+  val resolvers: Vector[sbt.librarymanagement.Resolver],
+  val otherResolvers: Vector[sbt.librarymanagement.Resolver],
+  val moduleConfigurations: Vector[sbt.librarymanagement.ModuleConfiguration],
+  val checksums: Vector[String],
+  val managedChecksums: Boolean,
+  val resolutionCacheDir: Option[java.io.File]) extends sbt.internal.librarymanagement.IvyConfiguration(lock, baseDirectory, log, updateOptions) with Serializable {
+  def this(
+  paths:                sbt.internal.librarymanagement.IvyPaths,
+  resolvers:            Vector[sbt.librarymanagement.Resolver],
+  otherResolvers:       Vector[sbt.librarymanagement.Resolver],
+  moduleConfigurations: Vector[sbt.librarymanagement.ModuleConfiguration],
+  lock:                 Option[xsbti.GlobalLock],
+  checksums:            Vector[String],
+  managedChecksums:     Boolean,
+  resolutionCacheDir:   Option[java.io.File],
+  updateOptions:        sbt.librarymanagement.UpdateOptions,
+  log:                  xsbti.Logger
+  ) =
+  this(lock, paths.baseDirectory, log, updateOptions, paths, resolvers, otherResolvers,
+  moduleConfigurations, checksums, managedChecksums, resolutionCacheDir)
+  
+  
+  override def equals(o: Any): Boolean = o match {
+    case x: InlineIvyConfiguration => (this.lock == x.lock) && (this.baseDirectory == x.baseDirectory) && (this.log == x.log) && (this.updateOptions == x.updateOptions) && (this.paths == x.paths) && (this.resolvers == x.resolvers) && (this.otherResolvers == x.otherResolvers) && (this.moduleConfigurations == x.moduleConfigurations) && (this.checksums == x.checksums) && (this.managedChecksums == x.managedChecksums) && (this.resolutionCacheDir == x.resolutionCacheDir)
+    case _ => false
+  }
+  override def hashCode: Int = {
+    37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (17 + "InlineIvyConfiguration".##) + lock.##) + baseDirectory.##) + log.##) + updateOptions.##) + paths.##) + resolvers.##) + otherResolvers.##) + moduleConfigurations.##) + checksums.##) + managedChecksums.##) + resolutionCacheDir.##)
+  }
+  override def toString: String = {
+    "InlineIvyConfiguration(" + lock + ", " + baseDirectory + ", " + log + ", " + updateOptions + ", " + paths + ", " + resolvers + ", " + otherResolvers + ", " + moduleConfigurations + ", " + checksums + ", " + managedChecksums + ", " + resolutionCacheDir + ")"
+  }
+  protected[this] def copy(lock: Option[xsbti.GlobalLock] = lock, baseDirectory: java.io.File = baseDirectory, log: xsbti.Logger = log, updateOptions: sbt.librarymanagement.UpdateOptions = updateOptions, paths: sbt.internal.librarymanagement.IvyPaths = paths, resolvers: Vector[sbt.librarymanagement.Resolver] = resolvers, otherResolvers: Vector[sbt.librarymanagement.Resolver] = otherResolvers, moduleConfigurations: Vector[sbt.librarymanagement.ModuleConfiguration] = moduleConfigurations, checksums: Vector[String] = checksums, managedChecksums: Boolean = managedChecksums, resolutionCacheDir: Option[java.io.File] = resolutionCacheDir): InlineIvyConfiguration = {
+    new InlineIvyConfiguration(lock, baseDirectory, log, updateOptions, paths, resolvers, otherResolvers, moduleConfigurations, checksums, managedChecksums, resolutionCacheDir)
+  }
+  def withLock(lock: Option[xsbti.GlobalLock]): InlineIvyConfiguration = {
+    copy(lock = lock)
+  }
+  def withLock(lock: xsbti.GlobalLock): InlineIvyConfiguration = {
+    copy(lock = Option(lock))
+  }
+  def withBaseDirectory(baseDirectory: java.io.File): InlineIvyConfiguration = {
+    copy(baseDirectory = baseDirectory)
+  }
+  def withLog(log: xsbti.Logger): InlineIvyConfiguration = {
+    copy(log = log)
+  }
+  def withUpdateOptions(updateOptions: sbt.librarymanagement.UpdateOptions): InlineIvyConfiguration = {
+    copy(updateOptions = updateOptions)
+  }
+  def withPaths(paths: sbt.internal.librarymanagement.IvyPaths): InlineIvyConfiguration = {
+    copy(paths = paths)
+  }
+  def withResolvers(resolvers: Vector[sbt.librarymanagement.Resolver]): InlineIvyConfiguration = {
+    copy(resolvers = resolvers)
+  }
+  def withOtherResolvers(otherResolvers: Vector[sbt.librarymanagement.Resolver]): InlineIvyConfiguration = {
+    copy(otherResolvers = otherResolvers)
+  }
+  def withModuleConfigurations(moduleConfigurations: Vector[sbt.librarymanagement.ModuleConfiguration]): InlineIvyConfiguration = {
+    copy(moduleConfigurations = moduleConfigurations)
+  }
+  def withChecksums(checksums: Vector[String]): InlineIvyConfiguration = {
+    copy(checksums = checksums)
+  }
+  def withManagedChecksums(managedChecksums: Boolean): InlineIvyConfiguration = {
+    copy(managedChecksums = managedChecksums)
+  }
+  def withResolutionCacheDir(resolutionCacheDir: Option[java.io.File]): InlineIvyConfiguration = {
+    copy(resolutionCacheDir = resolutionCacheDir)
+  }
+  def withResolutionCacheDir(resolutionCacheDir: java.io.File): InlineIvyConfiguration = {
+    copy(resolutionCacheDir = Option(resolutionCacheDir))
+  }
+}
+object InlineIvyConfiguration {
+  
+  def apply(lock: Option[xsbti.GlobalLock], baseDirectory: java.io.File, log: xsbti.Logger, updateOptions: sbt.librarymanagement.UpdateOptions, paths: sbt.internal.librarymanagement.IvyPaths, resolvers: Vector[sbt.librarymanagement.Resolver], otherResolvers: Vector[sbt.librarymanagement.Resolver], moduleConfigurations: Vector[sbt.librarymanagement.ModuleConfiguration], checksums: Vector[String], managedChecksums: Boolean, resolutionCacheDir: Option[java.io.File]): InlineIvyConfiguration = new InlineIvyConfiguration(lock, baseDirectory, log, updateOptions, paths, resolvers, otherResolvers, moduleConfigurations, checksums, managedChecksums, resolutionCacheDir)
+  def apply(lock: xsbti.GlobalLock, baseDirectory: java.io.File, log: xsbti.Logger, updateOptions: sbt.librarymanagement.UpdateOptions, paths: sbt.internal.librarymanagement.IvyPaths, resolvers: Vector[sbt.librarymanagement.Resolver], otherResolvers: Vector[sbt.librarymanagement.Resolver], moduleConfigurations: Vector[sbt.librarymanagement.ModuleConfiguration], checksums: Vector[String], managedChecksums: Boolean, resolutionCacheDir: java.io.File): InlineIvyConfiguration = new InlineIvyConfiguration(Option(lock), baseDirectory, log, updateOptions, paths, resolvers, otherResolvers, moduleConfigurations, checksums, managedChecksums, Option(resolutionCacheDir))
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/internal/librarymanagement/IvyConfiguration.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/internal/librarymanagement/IvyConfiguration.scala
@ -0,0 +1,29 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.librarymanagement
+abstract class IvyConfiguration(
+  val lock: Option[xsbti.GlobalLock],
+  val baseDirectory: java.io.File,
+  val log: xsbti.Logger,
+  val updateOptions: sbt.librarymanagement.UpdateOptions) extends Serializable {
+  
+  
+  
+  
+  override def equals(o: Any): Boolean = o match {
+    case x: IvyConfiguration => (this.lock == x.lock) && (this.baseDirectory == x.baseDirectory) && (this.log == x.log) && (this.updateOptions == x.updateOptions)
+    case _ => false
+  }
+  override def hashCode: Int = {
+    37 * (37 * (37 * (37 * (37 * (17 + "IvyConfiguration".##) + lock.##) + baseDirectory.##) + log.##) + updateOptions.##)
+  }
+  override def toString: String = {
+    "IvyConfiguration(" + lock + ", " + baseDirectory + ", " + log + ", " + updateOptions + ")"
+  }
+}
+object IvyConfiguration {
+  
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/internal/librarymanagement/IvyPaths.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/internal/librarymanagement/IvyPaths.scala
@ -0,0 +1,40 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.librarymanagement
+final class IvyPaths private (
+  val baseDirectory: java.io.File,
+  val ivyHome: Option[java.io.File]) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = o match {
+    case x: IvyPaths => (this.baseDirectory == x.baseDirectory) && (this.ivyHome == x.ivyHome)
+    case _ => false
+  }
+  override def hashCode: Int = {
+    37 * (37 * (37 * (17 + "IvyPaths".##) + baseDirectory.##) + ivyHome.##)
+  }
+  override def toString: String = {
+    "IvyPaths(" + baseDirectory + ", " + ivyHome + ")"
+  }
+  protected[this] def copy(baseDirectory: java.io.File = baseDirectory, ivyHome: Option[java.io.File] = ivyHome): IvyPaths = {
+    new IvyPaths(baseDirectory, ivyHome)
+  }
+  def withBaseDirectory(baseDirectory: java.io.File): IvyPaths = {
+    copy(baseDirectory = baseDirectory)
+  }
+  def withIvyHome(ivyHome: Option[java.io.File]): IvyPaths = {
+    copy(ivyHome = ivyHome)
+  }
+  def withIvyHome(ivyHome: java.io.File): IvyPaths = {
+    copy(ivyHome = Option(ivyHome))
+  }
+}
+object IvyPaths {
+  
+  def apply(baseDirectory: java.io.File, ivyHome: Option[java.io.File]): IvyPaths = new IvyPaths(baseDirectory, ivyHome)
+  def apply(baseDirectory: java.io.File, ivyHome: java.io.File): IvyPaths = new IvyPaths(baseDirectory, Option(ivyHome))
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/internal/librarymanagement/RetrieveConfiguration.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/internal/librarymanagement/RetrieveConfiguration.scala
@ -0,0 +1,45 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.librarymanagement
+final class RetrieveConfiguration private (
+  val retrieveDirectory: java.io.File,
+  val outputPattern: String,
+  val sync: Boolean,
+  val configurationsToRetrieve: Option[Set[sbt.librarymanagement.Configuration]]) extends Serializable {
+  
+  private def this(retrieveDirectory: java.io.File, outputPattern: String) = this(retrieveDirectory, outputPattern, false, None)
+  
+  override def equals(o: Any): Boolean = o match {
+    case x: RetrieveConfiguration => (this.retrieveDirectory == x.retrieveDirectory) && (this.outputPattern == x.outputPattern) && (this.sync == x.sync) && (this.configurationsToRetrieve == x.configurationsToRetrieve)
+    case _ => false
+  }
+  override def hashCode: Int = {
+    37 * (37 * (37 * (37 * (37 * (17 + "RetrieveConfiguration".##) + retrieveDirectory.##) + outputPattern.##) + sync.##) + configurationsToRetrieve.##)
+  }
+  override def toString: String = {
+    "RetrieveConfiguration(" + retrieveDirectory + ", " + outputPattern + ", " + sync + ", " + configurationsToRetrieve + ")"
+  }
+  protected[this] def copy(retrieveDirectory: java.io.File = retrieveDirectory, outputPattern: String = outputPattern, sync: Boolean = sync, configurationsToRetrieve: Option[Set[sbt.librarymanagement.Configuration]] = configurationsToRetrieve): RetrieveConfiguration = {
+    new RetrieveConfiguration(retrieveDirectory, outputPattern, sync, configurationsToRetrieve)
+  }
+  def withRetrieveDirectory(retrieveDirectory: java.io.File): RetrieveConfiguration = {
+    copy(retrieveDirectory = retrieveDirectory)
+  }
+  def withOutputPattern(outputPattern: String): RetrieveConfiguration = {
+    copy(outputPattern = outputPattern)
+  }
+  def withSync(sync: Boolean): RetrieveConfiguration = {
+    copy(sync = sync)
+  }
+  def withConfigurationsToRetrieve(configurationsToRetrieve: Option[Set[sbt.librarymanagement.Configuration]]): RetrieveConfiguration = {
+    copy(configurationsToRetrieve = configurationsToRetrieve)
+  }
+}
+object RetrieveConfiguration {
+  
+  def apply(retrieveDirectory: java.io.File, outputPattern: String): RetrieveConfiguration = new RetrieveConfiguration(retrieveDirectory, outputPattern, false, None)
+  def apply(retrieveDirectory: java.io.File, outputPattern: String, sync: Boolean, configurationsToRetrieve: Option[Set[sbt.librarymanagement.Configuration]]): RetrieveConfiguration = new RetrieveConfiguration(retrieveDirectory, outputPattern, sync, configurationsToRetrieve)
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/internal/librarymanagement/UpdateReportLite.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/internal/librarymanagement/UpdateReportLite.scala
@ -0,0 +1,32 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.internal.librarymanagement
+final class UpdateReportLite private (
+  val configurations: Vector[sbt.internal.librarymanagement.ConfigurationReportLite]) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = o match {
+    case x: UpdateReportLite => (this.configurations == x.configurations)
+    case _ => false
+  }
+  override def hashCode: Int = {
+    37 * (37 * (17 + "UpdateReportLite".##) + configurations.##)
+  }
+  override def toString: String = {
+    "UpdateReportLite(" + configurations + ")"
+  }
+  protected[this] def copy(configurations: Vector[sbt.internal.librarymanagement.ConfigurationReportLite] = configurations): UpdateReportLite = {
+    new UpdateReportLite(configurations)
+  }
+  def withConfigurations(configurations: Vector[sbt.internal.librarymanagement.ConfigurationReportLite]): UpdateReportLite = {
+    copy(configurations = configurations)
+  }
+}
+object UpdateReportLite {
+  
+  def apply(configurations: Vector[sbt.internal.librarymanagement.ConfigurationReportLite]): UpdateReportLite = new UpdateReportLite(configurations)
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/Artifact.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/Artifact.scala
@ -0,0 +1,61 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+final class Artifact private (
+  val name: String,
+  val `type`: String,
+  val extension: String,
+  val classifier: Option[String],
+  val configurations: Vector[sbt.librarymanagement.Configuration],
+  val url: Option[java.net.URL],
+  val extraAttributes: Map[String, String],
+  val checksum: Option[sbt.librarymanagement.Checksum]) extends sbt.librarymanagement.ArtifactExtra with Serializable {
+  
+  private def this(name: String) = this(name, Artifact.DefaultType, Artifact.DefaultExtension, None, Vector.empty, None, Map.empty, None)
+  
+  override def equals(o: Any): Boolean = o match {
+    case x: Artifact => (this.name == x.name) && (this.`type` == x.`type`) && (this.extension == x.extension) && (this.classifier == x.classifier) && (this.configurations == x.configurations) && (this.url == x.url) && (this.extraAttributes == x.extraAttributes) && (this.checksum == x.checksum)
+    case _ => false
+  }
+  override def hashCode: Int = {
+    37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (17 + "Artifact".##) + name.##) + `type`.##) + extension.##) + classifier.##) + configurations.##) + url.##) + extraAttributes.##) + checksum.##)
+  }
+  override def toString: String = {
+    "Artifact(" + name + ", " + `type` + ", " + extension + ", " + classifier + ", " + configurations + ", " + url + ", " + extraAttributes + ", " + checksum + ")"
+  }
+  protected[this] def copy(name: String = name, `type`: String = `type`, extension: String = extension, classifier: Option[String] = classifier, configurations: Vector[sbt.librarymanagement.Configuration] = configurations, url: Option[java.net.URL] = url, extraAttributes: Map[String, String] = extraAttributes, checksum: Option[sbt.librarymanagement.Checksum] = checksum): Artifact = {
+    new Artifact(name, `type`, extension, classifier, configurations, url, extraAttributes, checksum)
+  }
+  def withName(name: String): Artifact = {
+    copy(name = name)
+  }
+  def withType(`type`: String): Artifact = {
+    copy(`type` = `type`)
+  }
+  def withExtension(extension: String): Artifact = {
+    copy(extension = extension)
+  }
+  def withClassifier(classifier: Option[String]): Artifact = {
+    copy(classifier = classifier)
+  }
+  def withConfigurations(configurations: Vector[sbt.librarymanagement.Configuration]): Artifact = {
+    copy(configurations = configurations)
+  }
+  def withUrl(url: Option[java.net.URL]): Artifact = {
+    copy(url = url)
+  }
+  def withExtraAttributes(extraAttributes: Map[String, String]): Artifact = {
+    copy(extraAttributes = extraAttributes)
+  }
+  def withChecksum(checksum: Option[sbt.librarymanagement.Checksum]): Artifact = {
+    copy(checksum = checksum)
+  }
+}
+object Artifact extends sbt.librarymanagement.ArtifactFunctions {
+  
+  def apply(name: String): Artifact = new Artifact(name, Artifact.DefaultType, Artifact.DefaultExtension, None, Vector.empty, None, Map.empty, None)
+  def apply(name: String, `type`: String, extension: String, classifier: Option[String], configurations: Vector[sbt.librarymanagement.Configuration], url: Option[java.net.URL], extraAttributes: Map[String, String], checksum: Option[sbt.librarymanagement.Checksum]): Artifact = new Artifact(name, `type`, extension, classifier, configurations, url, extraAttributes, checksum)
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ArtifactFormats.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ArtifactFormats.scala
@ -0,0 +1,41 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait ArtifactFormats { self: sbt.librarymanagement.ConfigurationFormats with sbt.librarymanagement.ChecksumFormats with sjsonnew.BasicJsonProtocol =>
+implicit lazy val ArtifactFormat: JsonFormat[sbt.librarymanagement.Artifact] = new JsonFormat[sbt.librarymanagement.Artifact] {
+  override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.Artifact = {
+    jsOpt match {
+      case Some(js) =>
+      unbuilder.beginObject(js)
+      val name = unbuilder.readField[String]("name")
+      val `type` = unbuilder.readField[String]("type")
+      val extension = unbuilder.readField[String]("extension")
+      val classifier = unbuilder.readField[Option[String]]("classifier")
+      val configurations = unbuilder.readField[Vector[sbt.librarymanagement.Configuration]]("configurations")
+      val url = unbuilder.readField[Option[java.net.URL]]("url")
+      val extraAttributes = unbuilder.readField[Map[String, String]]("extraAttributes")
+      val checksum = unbuilder.readField[Option[sbt.librarymanagement.Checksum]]("checksum")
+      unbuilder.endObject()
+      sbt.librarymanagement.Artifact(name, `type`, extension, classifier, configurations, url, extraAttributes, checksum)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.librarymanagement.Artifact, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("name", obj.name)
+    builder.addField("type", obj.`type`)
+    builder.addField("extension", obj.extension)
+    builder.addField("classifier", obj.classifier)
+    builder.addField("configurations", obj.configurations)
+    builder.addField("url", obj.url)
+    builder.addField("extraAttributes", obj.extraAttributes)
+    builder.addField("checksum", obj.checksum)
+    builder.endObject()
+  }
+}
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ArtifactTypeFilter.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ArtifactTypeFilter.scala
@ -0,0 +1,43 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+/** Work around the inadequacy of Ivy's ArtifactTypeFilter (that it cannot reverse a filter) */
+final class ArtifactTypeFilter private (
+  /**
+   * Represents the artifact types that we should try to resolve for (as in the allowed values of
+   * `artifact[type]` from a dependency `<publications>` section). One can use this to filter
+   * source / doc artifacts.
+   */
+  val types: Set[String],
+  /** Whether to invert the types filter (i.e. allow only types NOT in the set) */
+  val inverted: Boolean) extends sbt.librarymanagement.ArtifactTypeFilterExtra with Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = o match {
+    case x: ArtifactTypeFilter => (this.types == x.types) && (this.inverted == x.inverted)
+    case _ => false
+  }
+  override def hashCode: Int = {
+    37 * (37 * (37 * (17 + "ArtifactTypeFilter".##) + types.##) + inverted.##)
+  }
+  override def toString: String = {
+    "ArtifactTypeFilter(" + types + ", " + inverted + ")"
+  }
+  protected[this] def copy(types: Set[String] = types, inverted: Boolean = inverted): ArtifactTypeFilter = {
+    new ArtifactTypeFilter(types, inverted)
+  }
+  def withTypes(types: Set[String]): ArtifactTypeFilter = {
+    copy(types = types)
+  }
+  def withInverted(inverted: Boolean): ArtifactTypeFilter = {
+    copy(inverted = inverted)
+  }
+}
+object ArtifactTypeFilter extends sbt.librarymanagement.ArtifactTypeFilterFunctions {
+  
+  def apply(types: Set[String], inverted: Boolean): ArtifactTypeFilter = new ArtifactTypeFilter(types, inverted)
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ArtifactTypeFilterFormats.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ArtifactTypeFilterFormats.scala
@ -0,0 +1,29 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait ArtifactTypeFilterFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val ArtifactTypeFilterFormat: JsonFormat[sbt.librarymanagement.ArtifactTypeFilter] = new JsonFormat[sbt.librarymanagement.ArtifactTypeFilter] {
+  override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.ArtifactTypeFilter = {
+    jsOpt match {
+      case Some(js) =>
+      unbuilder.beginObject(js)
+      val types = unbuilder.readField[Set[String]]("types")
+      val inverted = unbuilder.readField[Boolean]("inverted")
+      unbuilder.endObject()
+      sbt.librarymanagement.ArtifactTypeFilter(types, inverted)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.librarymanagement.ArtifactTypeFilter, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("types", obj.types)
+    builder.addField("inverted", obj.inverted)
+    builder.endObject()
+  }
+}
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/Binary.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/Binary.scala
@ -0,0 +1,43 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+/**
+ * Cross-versions a module using the result of
+ * prepending `prefix` and appending `suffix` to the binary version.
+ * For example, if `prefix = "foo_"` and `suffix = "_bar"` and the binary version is "2.10",
+ * the module is cross-versioned with "foo_2.10_bar".
+ */
+final class Binary private (
+  val prefix: String,
+  val suffix: String) extends sbt.librarymanagement.CrossVersion() with Serializable {
+  
+  private def this() = this("", "")
+  
+  override def equals(o: Any): Boolean = o match {
+    case x: Binary => (this.prefix == x.prefix) && (this.suffix == x.suffix)
+    case _ => false
+  }
+  override def hashCode: Int = {
+    37 * (37 * (37 * (17 + "Binary".##) + prefix.##) + suffix.##)
+  }
+  override def toString: String = {
+    "Binary(" + prefix + ", " + suffix + ")"
+  }
+  protected[this] def copy(prefix: String = prefix, suffix: String = suffix): Binary = {
+    new Binary(prefix, suffix)
+  }
+  def withPrefix(prefix: String): Binary = {
+    copy(prefix = prefix)
+  }
+  def withSuffix(suffix: String): Binary = {
+    copy(suffix = suffix)
+  }
+}
+object Binary {
+  
+  def apply(): Binary = new Binary("", "")
+  def apply(prefix: String, suffix: String): Binary = new Binary(prefix, suffix)
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/BinaryFormats.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/BinaryFormats.scala
@ -0,0 +1,29 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait BinaryFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val BinaryFormat: JsonFormat[sbt.librarymanagement.Binary] = new JsonFormat[sbt.librarymanagement.Binary] {
+  override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.Binary = {
+    jsOpt match {
+      case Some(js) =>
+      unbuilder.beginObject(js)
+      val prefix = unbuilder.readField[String]("prefix")
+      val suffix = unbuilder.readField[String]("suffix")
+      unbuilder.endObject()
+      sbt.librarymanagement.Binary(prefix, suffix)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.librarymanagement.Binary, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("prefix", obj.prefix)
+    builder.addField("suffix", obj.suffix)
+    builder.endObject()
+  }
+}
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/Caller.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/Caller.scala
@ -0,0 +1,56 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+final class Caller private (
+  val caller: sbt.librarymanagement.ModuleID,
+  val callerConfigurations: Vector[String],
+  val callerExtraAttributes: Map[String, String],
+  val isForceDependency: Boolean,
+  val isChangingDependency: Boolean,
+  val isTransitiveDependency: Boolean,
+  val isDirectlyForceDependency: Boolean) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = o match {
+    case x: Caller => (this.caller == x.caller) && (this.callerConfigurations == x.callerConfigurations) && (this.callerExtraAttributes == x.callerExtraAttributes) && (this.isForceDependency == x.isForceDependency) && (this.isChangingDependency == x.isChangingDependency) && (this.isTransitiveDependency == x.isTransitiveDependency) && (this.isDirectlyForceDependency == x.isDirectlyForceDependency)
+    case _ => false
+  }
+  override def hashCode: Int = {
+    37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (17 + "Caller".##) + caller.##) + callerConfigurations.##) + callerExtraAttributes.##) + isForceDependency.##) + isChangingDependency.##) + isTransitiveDependency.##) + isDirectlyForceDependency.##)
+  }
+  override def toString: String = {
+    s"$caller"
+  }
+  protected[this] def copy(caller: sbt.librarymanagement.ModuleID = caller, callerConfigurations: Vector[String] = callerConfigurations, callerExtraAttributes: Map[String, String] = callerExtraAttributes, isForceDependency: Boolean = isForceDependency, isChangingDependency: Boolean = isChangingDependency, isTransitiveDependency: Boolean = isTransitiveDependency, isDirectlyForceDependency: Boolean = isDirectlyForceDependency): Caller = {
+    new Caller(caller, callerConfigurations, callerExtraAttributes, isForceDependency, isChangingDependency, isTransitiveDependency, isDirectlyForceDependency)
+  }
+  def withCaller(caller: sbt.librarymanagement.ModuleID): Caller = {
+    copy(caller = caller)
+  }
+  def withCallerConfigurations(callerConfigurations: Vector[String]): Caller = {
+    copy(callerConfigurations = callerConfigurations)
+  }
+  def withCallerExtraAttributes(callerExtraAttributes: Map[String, String]): Caller = {
+    copy(callerExtraAttributes = callerExtraAttributes)
+  }
+  def withIsForceDependency(isForceDependency: Boolean): Caller = {
+    copy(isForceDependency = isForceDependency)
+  }
+  def withIsChangingDependency(isChangingDependency: Boolean): Caller = {
+    copy(isChangingDependency = isChangingDependency)
+  }
+  def withIsTransitiveDependency(isTransitiveDependency: Boolean): Caller = {
+    copy(isTransitiveDependency = isTransitiveDependency)
+  }
+  def withIsDirectlyForceDependency(isDirectlyForceDependency: Boolean): Caller = {
+    copy(isDirectlyForceDependency = isDirectlyForceDependency)
+  }
+}
+object Caller {
+  
+  def apply(caller: sbt.librarymanagement.ModuleID, callerConfigurations: Vector[String], callerExtraAttributes: Map[String, String], isForceDependency: Boolean, isChangingDependency: Boolean, isTransitiveDependency: Boolean, isDirectlyForceDependency: Boolean): Caller = new Caller(caller, callerConfigurations, callerExtraAttributes, isForceDependency, isChangingDependency, isTransitiveDependency, isDirectlyForceDependency)
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/CallerFormats.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/CallerFormats.scala
@ -0,0 +1,39 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait CallerFormats { self: sbt.librarymanagement.ModuleIDFormats with sjsonnew.BasicJsonProtocol =>
+implicit lazy val CallerFormat: JsonFormat[sbt.librarymanagement.Caller] = new JsonFormat[sbt.librarymanagement.Caller] {
+  override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.Caller = {
+    jsOpt match {
+      case Some(js) =>
+      unbuilder.beginObject(js)
+      val caller = unbuilder.readField[sbt.librarymanagement.ModuleID]("caller")
+      val callerConfigurations = unbuilder.readField[Vector[String]]("callerConfigurations")
+      val callerExtraAttributes = unbuilder.readField[Map[String, String]]("callerExtraAttributes")
+      val isForceDependency = unbuilder.readField[Boolean]("isForceDependency")
+      val isChangingDependency = unbuilder.readField[Boolean]("isChangingDependency")
+      val isTransitiveDependency = unbuilder.readField[Boolean]("isTransitiveDependency")
+      val isDirectlyForceDependency = unbuilder.readField[Boolean]("isDirectlyForceDependency")
+      unbuilder.endObject()
+      sbt.librarymanagement.Caller(caller, callerConfigurations, callerExtraAttributes, isForceDependency, isChangingDependency, isTransitiveDependency, isDirectlyForceDependency)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.librarymanagement.Caller, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("caller", obj.caller)
+    builder.addField("callerConfigurations", obj.callerConfigurations)
+    builder.addField("callerExtraAttributes", obj.callerExtraAttributes)
+    builder.addField("isForceDependency", obj.isForceDependency)
+    builder.addField("isChangingDependency", obj.isChangingDependency)
+    builder.addField("isTransitiveDependency", obj.isTransitiveDependency)
+    builder.addField("isDirectlyForceDependency", obj.isDirectlyForceDependency)
+    builder.endObject()
+  }
+}
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ChainedResolver.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ChainedResolver.scala
@ -0,0 +1,36 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+final class ChainedResolver private (
+  name: String,
+  val resolvers: Vector[sbt.librarymanagement.Resolver]) extends sbt.librarymanagement.Resolver(name) with Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = o match {
+    case x: ChainedResolver => (this.name == x.name) && (this.resolvers == x.resolvers)
+    case _ => false
+  }
+  override def hashCode: Int = {
+    37 * (37 * (37 * (17 + "ChainedResolver".##) + name.##) + resolvers.##)
+  }
+  override def toString: String = {
+    "ChainedResolver(" + name + ", " + resolvers + ")"
+  }
+  protected[this] def copy(name: String = name, resolvers: Vector[sbt.librarymanagement.Resolver] = resolvers): ChainedResolver = {
+    new ChainedResolver(name, resolvers)
+  }
+  def withName(name: String): ChainedResolver = {
+    copy(name = name)
+  }
+  def withResolvers(resolvers: Vector[sbt.librarymanagement.Resolver]): ChainedResolver = {
+    copy(resolvers = resolvers)
+  }
+}
+object ChainedResolver {
+  
+  def apply(name: String, resolvers: Vector[sbt.librarymanagement.Resolver]): ChainedResolver = new ChainedResolver(name, resolvers)
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ChainedResolverFormats.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ChainedResolverFormats.scala
@ -0,0 +1,29 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait ChainedResolverFormats { self: sbt.librarymanagement.ResolverFormats with sjsonnew.BasicJsonProtocol =>
+implicit lazy val ChainedResolverFormat: JsonFormat[sbt.librarymanagement.ChainedResolver] = new JsonFormat[sbt.librarymanagement.ChainedResolver] {
+  override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.ChainedResolver = {
+    jsOpt match {
+      case Some(js) =>
+      unbuilder.beginObject(js)
+      val name = unbuilder.readField[String]("name")
+      val resolvers = unbuilder.readField[Vector[sbt.librarymanagement.Resolver]]("resolvers")
+      unbuilder.endObject()
+      sbt.librarymanagement.ChainedResolver(name, resolvers)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.librarymanagement.ChainedResolver, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("name", obj.name)
+    builder.addField("resolvers", obj.resolvers)
+    builder.endObject()
+  }
+}
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/Checksum.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/Checksum.scala
@ -0,0 +1,36 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+final class Checksum private (
+  val digest: String,
+  val `type`: String) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = o match {
+    case x: Checksum => (this.digest == x.digest) && (this.`type` == x.`type`)
+    case _ => false
+  }
+  override def hashCode: Int = {
+    37 * (37 * (37 * (17 + "Checksum".##) + digest.##) + `type`.##)
+  }
+  override def toString: String = {
+    "Checksum(" + digest + ", " + `type` + ")"
+  }
+  protected[this] def copy(digest: String = digest, `type`: String = `type`): Checksum = {
+    new Checksum(digest, `type`)
+  }
+  def withDigest(digest: String): Checksum = {
+    copy(digest = digest)
+  }
+  def withType(`type`: String): Checksum = {
+    copy(`type` = `type`)
+  }
+}
+object Checksum {
+  
+  def apply(digest: String, `type`: String): Checksum = new Checksum(digest, `type`)
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ChecksumFormats.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ChecksumFormats.scala
@ -0,0 +1,29 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait ChecksumFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val ChecksumFormat: JsonFormat[sbt.librarymanagement.Checksum] = new JsonFormat[sbt.librarymanagement.Checksum] {
+  override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.Checksum = {
+    jsOpt match {
+      case Some(js) =>
+      unbuilder.beginObject(js)
+      val digest = unbuilder.readField[String]("digest")
+      val `type` = unbuilder.readField[String]("type")
+      unbuilder.endObject()
+      sbt.librarymanagement.Checksum(digest, `type`)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.librarymanagement.Checksum, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("digest", obj.digest)
+    builder.addField("type", obj.`type`)
+    builder.endObject()
+  }
+}
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/Configuration.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/Configuration.scala
@ -0,0 +1,50 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+/** Represents an Ivy configuration. */
+final class Configuration private (
+  val name: String,
+  val description: String,
+  val isPublic: Boolean,
+  val extendsConfigs: Vector[sbt.librarymanagement.Configuration],
+  val transitive: Boolean) extends sbt.librarymanagement.ConfigurationExtra with Serializable {
+  
+  private def this(name: String) = this(name, "", true, Vector.empty, true)
+  
+  override def equals(o: Any): Boolean = o match {
+    case x: Configuration => (this.name == x.name) && (this.description == x.description) && (this.isPublic == x.isPublic) && (this.extendsConfigs == x.extendsConfigs) && (this.transitive == x.transitive)
+    case _ => false
+  }
+  override def hashCode: Int = {
+    37 * (37 * (37 * (37 * (37 * (37 * (17 + "Configuration".##) + name.##) + description.##) + isPublic.##) + extendsConfigs.##) + transitive.##)
+  }
+  override def toString: String = {
+    name
+  }
+  protected[this] def copy(name: String = name, description: String = description, isPublic: Boolean = isPublic, extendsConfigs: Vector[sbt.librarymanagement.Configuration] = extendsConfigs, transitive: Boolean = transitive): Configuration = {
+    new Configuration(name, description, isPublic, extendsConfigs, transitive)
+  }
+  def withName(name: String): Configuration = {
+    copy(name = name)
+  }
+  def withDescription(description: String): Configuration = {
+    copy(description = description)
+  }
+  def withIsPublic(isPublic: Boolean): Configuration = {
+    copy(isPublic = isPublic)
+  }
+  def withExtendsConfigs(extendsConfigs: Vector[sbt.librarymanagement.Configuration]): Configuration = {
+    copy(extendsConfigs = extendsConfigs)
+  }
+  def withTransitive(transitive: Boolean): Configuration = {
+    copy(transitive = transitive)
+  }
+}
+object Configuration {
+  
+  def apply(name: String): Configuration = new Configuration(name, "", true, Vector.empty, true)
+  def apply(name: String, description: String, isPublic: Boolean, extendsConfigs: Vector[sbt.librarymanagement.Configuration], transitive: Boolean): Configuration = new Configuration(name, description, isPublic, extendsConfigs, transitive)
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ConfigurationFormats.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ConfigurationFormats.scala
@ -0,0 +1,35 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait ConfigurationFormats { self: sbt.librarymanagement.ConfigurationFormats with sjsonnew.BasicJsonProtocol =>
+implicit lazy val ConfigurationFormat: JsonFormat[sbt.librarymanagement.Configuration] = new JsonFormat[sbt.librarymanagement.Configuration] {
+  override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.Configuration = {
+    jsOpt match {
+      case Some(js) =>
+      unbuilder.beginObject(js)
+      val name = unbuilder.readField[String]("name")
+      val description = unbuilder.readField[String]("description")
+      val isPublic = unbuilder.readField[Boolean]("isPublic")
+      val extendsConfigs = unbuilder.readField[Vector[sbt.librarymanagement.Configuration]]("extendsConfigs")
+      val transitive = unbuilder.readField[Boolean]("transitive")
+      unbuilder.endObject()
+      sbt.librarymanagement.Configuration(name, description, isPublic, extendsConfigs, transitive)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.librarymanagement.Configuration, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("name", obj.name)
+    builder.addField("description", obj.description)
+    builder.addField("isPublic", obj.isPublic)
+    builder.addField("extendsConfigs", obj.extendsConfigs)
+    builder.addField("transitive", obj.transitive)
+    builder.endObject()
+  }
+}
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ConfigurationReport.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ConfigurationReport.scala
@ -0,0 +1,46 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+/** Provides information about resolution of a single configuration. */
+final class ConfigurationReport private (
+  /** the configuration this report is for. */
+  val configuration: String,
+  /** a sequence containing one report for each module resolved for this configuration. */
+  val modules: Vector[sbt.librarymanagement.ModuleReport],
+  /** a sequence containing one report for each org/name, which may or may not be part of the final resolution. */
+  val details: Vector[sbt.librarymanagement.OrganizationArtifactReport]) extends sbt.librarymanagement.ConfigurationReportExtra with Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = o match {
+    case x: ConfigurationReport => (this.configuration == x.configuration) && (this.modules == x.modules) && (this.details == x.details)
+    case _ => false
+  }
+  override def hashCode: Int = {
+    37 * (37 * (37 * (37 * (17 + "ConfigurationReport".##) + configuration.##) + modules.##) + details.##)
+  }
+  override def toString: String = {
+    s"\t$configuration:\n" +
+    (if (details.isEmpty) modules.mkString + details.flatMap(_.modules).filter(_.evicted).map("\t\t(EVICTED) " + _ + "\n").mkString
+    else details.mkString)
+  }
+  protected[this] def copy(configuration: String = configuration, modules: Vector[sbt.librarymanagement.ModuleReport] = modules, details: Vector[sbt.librarymanagement.OrganizationArtifactReport] = details): ConfigurationReport = {
+    new ConfigurationReport(configuration, modules, details)
+  }
+  def withConfiguration(configuration: String): ConfigurationReport = {
+    copy(configuration = configuration)
+  }
+  def withModules(modules: Vector[sbt.librarymanagement.ModuleReport]): ConfigurationReport = {
+    copy(modules = modules)
+  }
+  def withDetails(details: Vector[sbt.librarymanagement.OrganizationArtifactReport]): ConfigurationReport = {
+    copy(details = details)
+  }
+}
+object ConfigurationReport {
+  
+  def apply(configuration: String, modules: Vector[sbt.librarymanagement.ModuleReport], details: Vector[sbt.librarymanagement.OrganizationArtifactReport]): ConfigurationReport = new ConfigurationReport(configuration, modules, details)
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ConfigurationReportFormats.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ConfigurationReportFormats.scala
@ -0,0 +1,31 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait ConfigurationReportFormats { self: sbt.librarymanagement.ModuleReportFormats with sbt.librarymanagement.OrganizationArtifactReportFormats with sjsonnew.BasicJsonProtocol =>
+implicit lazy val ConfigurationReportFormat: JsonFormat[sbt.librarymanagement.ConfigurationReport] = new JsonFormat[sbt.librarymanagement.ConfigurationReport] {
+  override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.ConfigurationReport = {
+    jsOpt match {
+      case Some(js) =>
+      unbuilder.beginObject(js)
+      val configuration = unbuilder.readField[String]("configuration")
+      val modules = unbuilder.readField[Vector[sbt.librarymanagement.ModuleReport]]("modules")
+      val details = unbuilder.readField[Vector[sbt.librarymanagement.OrganizationArtifactReport]]("details")
+      unbuilder.endObject()
+      sbt.librarymanagement.ConfigurationReport(configuration, modules, details)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.librarymanagement.ConfigurationReport, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("configuration", obj.configuration)
+    builder.addField("modules", obj.modules)
+    builder.addField("details", obj.details)
+    builder.endObject()
+  }
+}
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ConfigurationReportLiteFormats.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ConfigurationReportLiteFormats.scala
@ -0,0 +1,29 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait ConfigurationReportLiteFormats { self: sbt.librarymanagement.OrganizationArtifactReportFormats with sjsonnew.BasicJsonProtocol =>
+implicit lazy val ConfigurationReportLiteFormat: JsonFormat[sbt.internal.librarymanagement.ConfigurationReportLite] = new JsonFormat[sbt.internal.librarymanagement.ConfigurationReportLite] {
+  override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.librarymanagement.ConfigurationReportLite = {
+    jsOpt match {
+      case Some(js) =>
+      unbuilder.beginObject(js)
+      val configuration = unbuilder.readField[String]("configuration")
+      val details = unbuilder.readField[Vector[sbt.librarymanagement.OrganizationArtifactReport]]("details")
+      unbuilder.endObject()
+      sbt.internal.librarymanagement.ConfigurationReportLite(configuration, details)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.librarymanagement.ConfigurationReportLite, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("configuration", obj.configuration)
+    builder.addField("details", obj.details)
+    builder.endObject()
+  }
+}
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ConflictManager.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ConflictManager.scala
@ -0,0 +1,42 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+/** See http://ant.apache.org/ivy/history/latest-milestone/settings/conflict-managers.html for details of the different conflict managers. */
+final class ConflictManager private (
+  val name: String,
+  val organization: String,
+  val module: String) extends Serializable {
+  
+  private def this(name: String) = this(name, "*", "*")
+  
+  override def equals(o: Any): Boolean = o match {
+    case x: ConflictManager => (this.name == x.name) && (this.organization == x.organization) && (this.module == x.module)
+    case _ => false
+  }
+  override def hashCode: Int = {
+    37 * (37 * (37 * (37 * (17 + "ConflictManager".##) + name.##) + organization.##) + module.##)
+  }
+  override def toString: String = {
+    "ConflictManager(" + name + ", " + organization + ", " + module + ")"
+  }
+  protected[this] def copy(name: String = name, organization: String = organization, module: String = module): ConflictManager = {
+    new ConflictManager(name, organization, module)
+  }
+  def withName(name: String): ConflictManager = {
+    copy(name = name)
+  }
+  def withOrganization(organization: String): ConflictManager = {
+    copy(organization = organization)
+  }
+  def withModule(module: String): ConflictManager = {
+    copy(module = module)
+  }
+}
+object ConflictManager extends sbt.librarymanagement.ConflictManagerFunctions {
+  
+  def apply(name: String): ConflictManager = new ConflictManager(name, "*", "*")
+  def apply(name: String, organization: String, module: String): ConflictManager = new ConflictManager(name, organization, module)
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ConflictManagerFormats.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ConflictManagerFormats.scala
@ -0,0 +1,31 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait ConflictManagerFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val ConflictManagerFormat: JsonFormat[sbt.librarymanagement.ConflictManager] = new JsonFormat[sbt.librarymanagement.ConflictManager] {
+  override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.ConflictManager = {
+    jsOpt match {
+      case Some(js) =>
+      unbuilder.beginObject(js)
+      val name = unbuilder.readField[String]("name")
+      val organization = unbuilder.readField[String]("organization")
+      val module = unbuilder.readField[String]("module")
+      unbuilder.endObject()
+      sbt.librarymanagement.ConflictManager(name, organization, module)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.librarymanagement.ConflictManager, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("name", obj.name)
+    builder.addField("organization", obj.organization)
+    builder.addField("module", obj.module)
+    builder.endObject()
+  }
+}
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/Constant.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/Constant.scala
@ -0,0 +1,34 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+/** Cross-versions a module using the string `value`. */
+final class Constant private (
+  val value: String) extends sbt.librarymanagement.CrossVersion() with Serializable {
+  
+  private def this() = this("")
+  
+  override def equals(o: Any): Boolean = o match {
+    case x: Constant => (this.value == x.value)
+    case _ => false
+  }
+  override def hashCode: Int = {
+    37 * (37 * (17 + "Constant".##) + value.##)
+  }
+  override def toString: String = {
+    "Constant(" + value + ")"
+  }
+  protected[this] def copy(value: String = value): Constant = {
+    new Constant(value)
+  }
+  def withValue(value: String): Constant = {
+    copy(value = value)
+  }
+}
+object Constant {
+  
+  def apply(): Constant = new Constant("")
+  def apply(value: String): Constant = new Constant(value)
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ConstantFormats.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ConstantFormats.scala
@ -0,0 +1,27 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait ConstantFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val ConstantFormat: JsonFormat[sbt.librarymanagement.Constant] = new JsonFormat[sbt.librarymanagement.Constant] {
+  override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.Constant = {
+    jsOpt match {
+      case Some(js) =>
+      unbuilder.beginObject(js)
+      val value = unbuilder.readField[String]("value")
+      unbuilder.endObject()
+      sbt.librarymanagement.Constant(value)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.librarymanagement.Constant, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("value", obj.value)
+    builder.endObject()
+  }
+}
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/CrossVersion.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/CrossVersion.scala
@ -0,0 +1,26 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+/** Configures how a module will be cross-versioned. */
+abstract class CrossVersion() extends Serializable {
+
+
+
+
+override def equals(o: Any): Boolean = o match {
+  case x: CrossVersion => true
+  case _ => false
+}
+override def hashCode: Int = {
+  37 * (17 + "CrossVersion".##)
+}
+override def toString: String = {
+  "CrossVersion()"
+}
+}
+object CrossVersion extends sbt.librarymanagement.CrossVersionFunctions {
+  
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/CrossVersionFormats.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/CrossVersionFormats.scala
@ -0,0 +1,11 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+
+import _root_.sjsonnew.JsonFormat
+trait CrossVersionFormats { self: sjsonnew.BasicJsonProtocol with sbt.librarymanagement.DisabledFormats with sbt.librarymanagement.BinaryFormats with sbt.librarymanagement.ConstantFormats with sbt.librarymanagement.PatchFormats with sbt.librarymanagement.FullFormats =>
+implicit lazy val CrossVersionFormat: JsonFormat[sbt.librarymanagement.CrossVersion] = flatUnionFormat5[sbt.librarymanagement.CrossVersion, sbt.librarymanagement.Disabled, sbt.librarymanagement.Binary, sbt.librarymanagement.Constant, sbt.librarymanagement.Patch, sbt.librarymanagement.Full]("type")
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/Developer.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/Developer.scala
@ -0,0 +1,44 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+final class Developer private (
+  val id: String,
+  val name: String,
+  val email: String,
+  val url: java.net.URL) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = o match {
+    case x: Developer => (this.id == x.id) && (this.name == x.name) && (this.email == x.email) && (this.url == x.url)
+    case _ => false
+  }
+  override def hashCode: Int = {
+    37 * (37 * (37 * (37 * (37 * (17 + "Developer".##) + id.##) + name.##) + email.##) + url.##)
+  }
+  override def toString: String = {
+    "Developer(" + id + ", " + name + ", " + email + ", " + url + ")"
+  }
+  protected[this] def copy(id: String = id, name: String = name, email: String = email, url: java.net.URL = url): Developer = {
+    new Developer(id, name, email, url)
+  }
+  def withId(id: String): Developer = {
+    copy(id = id)
+  }
+  def withName(name: String): Developer = {
+    copy(name = name)
+  }
+  def withEmail(email: String): Developer = {
+    copy(email = email)
+  }
+  def withUrl(url: java.net.URL): Developer = {
+    copy(url = url)
+  }
+}
+object Developer {
+  
+  def apply(id: String, name: String, email: String, url: java.net.URL): Developer = new Developer(id, name, email, url)
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/DeveloperFormats.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/DeveloperFormats.scala
@ -0,0 +1,33 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait DeveloperFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val DeveloperFormat: JsonFormat[sbt.librarymanagement.Developer] = new JsonFormat[sbt.librarymanagement.Developer] {
+  override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.Developer = {
+    jsOpt match {
+      case Some(js) =>
+      unbuilder.beginObject(js)
+      val id = unbuilder.readField[String]("id")
+      val name = unbuilder.readField[String]("name")
+      val email = unbuilder.readField[String]("email")
+      val url = unbuilder.readField[java.net.URL]("url")
+      unbuilder.endObject()
+      sbt.librarymanagement.Developer(id, name, email, url)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.librarymanagement.Developer, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("id", obj.id)
+    builder.addField("name", obj.name)
+    builder.addField("email", obj.email)
+    builder.addField("url", obj.url)
+    builder.endObject()
+  }
+}
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/Disabled.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/Disabled.scala
@ -0,0 +1,30 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+/** Disables cross versioning for a module. */
+final class Disabled private () extends sbt.librarymanagement.CrossVersion() with Serializable {
+
+
+
+override def equals(o: Any): Boolean = o match {
+  case x: Disabled => true
+  case _ => false
+}
+override def hashCode: Int = {
+  37 * (17 + "Disabled".##)
+}
+override def toString: String = {
+  "Disabled()"
+}
+protected[this] def copy(): Disabled = {
+  new Disabled()
+}
+
+}
+object Disabled {
+  
+  def apply(): Disabled = new Disabled()
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/DisabledFormats.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/DisabledFormats.scala
@ -0,0 +1,27 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait DisabledFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val DisabledFormat: JsonFormat[sbt.librarymanagement.Disabled] = new JsonFormat[sbt.librarymanagement.Disabled] {
+  override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.Disabled = {
+    jsOpt match {
+      case Some(js) =>
+      unbuilder.beginObject(js)
+      
+      unbuilder.endObject()
+      sbt.librarymanagement.Disabled()
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.librarymanagement.Disabled, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    
+    builder.endObject()
+  }
+}
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ExternalIvyConfigurationFormats.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ExternalIvyConfigurationFormats.scala
@ -0,0 +1,37 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait ExternalIvyConfigurationFormats { self: sbt.internal.librarymanagement.formats.GlobalLockFormat with sbt.internal.librarymanagement.formats.LoggerFormat with sbt.internal.librarymanagement.formats.UpdateOptionsFormat with sbt.librarymanagement.ResolverFormats with sjsonnew.BasicJsonProtocol =>
+implicit lazy val ExternalIvyConfigurationFormat: JsonFormat[sbt.internal.librarymanagement.ExternalIvyConfiguration] = new JsonFormat[sbt.internal.librarymanagement.ExternalIvyConfiguration] {
+  override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.librarymanagement.ExternalIvyConfiguration = {
+    jsOpt match {
+      case Some(js) =>
+      unbuilder.beginObject(js)
+      val lock = unbuilder.readField[Option[xsbti.GlobalLock]]("lock")
+      val baseDirectory = unbuilder.readField[java.io.File]("baseDirectory")
+      val log = unbuilder.readField[xsbti.Logger]("log")
+      val updateOptions = unbuilder.readField[sbt.librarymanagement.UpdateOptions]("updateOptions")
+      val uri = unbuilder.readField[java.net.URI]("uri")
+      val extraResolvers = unbuilder.readField[Vector[sbt.librarymanagement.Resolver]]("extraResolvers")
+      unbuilder.endObject()
+      sbt.internal.librarymanagement.ExternalIvyConfiguration(lock, baseDirectory, log, updateOptions, uri, extraResolvers)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.librarymanagement.ExternalIvyConfiguration, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("lock", obj.lock)
+    builder.addField("baseDirectory", obj.baseDirectory)
+    builder.addField("log", obj.log)
+    builder.addField("updateOptions", obj.updateOptions)
+    builder.addField("uri", obj.uri)
+    builder.addField("extraResolvers", obj.extraResolvers)
+    builder.endObject()
+  }
+}
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/FileConfiguration.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/FileConfiguration.scala
@ -0,0 +1,41 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+/** Configuration specific to an Ivy filesystem resolver. */
+final class FileConfiguration private (
+  val isLocal: Boolean,
+  val isTransactional: Option[Boolean]) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = o match {
+    case x: FileConfiguration => (this.isLocal == x.isLocal) && (this.isTransactional == x.isTransactional)
+    case _ => false
+  }
+  override def hashCode: Int = {
+    37 * (37 * (37 * (17 + "FileConfiguration".##) + isLocal.##) + isTransactional.##)
+  }
+  override def toString: String = {
+    "FileConfiguration(" + isLocal + ", " + isTransactional + ")"
+  }
+  protected[this] def copy(isLocal: Boolean = isLocal, isTransactional: Option[Boolean] = isTransactional): FileConfiguration = {
+    new FileConfiguration(isLocal, isTransactional)
+  }
+  def withIsLocal(isLocal: Boolean): FileConfiguration = {
+    copy(isLocal = isLocal)
+  }
+  def withIsTransactional(isTransactional: Option[Boolean]): FileConfiguration = {
+    copy(isTransactional = isTransactional)
+  }
+  def withIsTransactional(isTransactional: Boolean): FileConfiguration = {
+    copy(isTransactional = Option(isTransactional))
+  }
+}
+object FileConfiguration {
+  
+  def apply(isLocal: Boolean, isTransactional: Option[Boolean]): FileConfiguration = new FileConfiguration(isLocal, isTransactional)
+  def apply(isLocal: Boolean, isTransactional: Boolean): FileConfiguration = new FileConfiguration(isLocal, Option(isTransactional))
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/FileConfigurationFormats.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/FileConfigurationFormats.scala
@ -0,0 +1,29 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait FileConfigurationFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val FileConfigurationFormat: JsonFormat[sbt.librarymanagement.FileConfiguration] = new JsonFormat[sbt.librarymanagement.FileConfiguration] {
+  override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.FileConfiguration = {
+    jsOpt match {
+      case Some(js) =>
+      unbuilder.beginObject(js)
+      val isLocal = unbuilder.readField[Boolean]("isLocal")
+      val isTransactional = unbuilder.readField[Option[Boolean]]("isTransactional")
+      unbuilder.endObject()
+      sbt.librarymanagement.FileConfiguration(isLocal, isTransactional)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.librarymanagement.FileConfiguration, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("isLocal", obj.isLocal)
+    builder.addField("isTransactional", obj.isTransactional)
+    builder.endObject()
+  }
+}
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/FileRepository.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/FileRepository.scala
@ -0,0 +1,43 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+/** sbt interface for an Ivy filesystem repository.  More convenient construction is done using Resolver.file. */
+final class FileRepository private (
+  name: String,
+  patterns: sbt.librarymanagement.Patterns,
+  val configuration: sbt.librarymanagement.FileConfiguration) extends sbt.librarymanagement.PatternsBasedRepository(name, patterns) with Serializable {
+  def this(name: String, configuration: sbt.librarymanagement.FileConfiguration, patterns: sbt.librarymanagement.Patterns) =
+  this(name, patterns, configuration)
+  
+  
+  override def equals(o: Any): Boolean = o match {
+    case x: FileRepository => (this.name == x.name) && (this.patterns == x.patterns) && (this.configuration == x.configuration)
+    case _ => false
+  }
+  override def hashCode: Int = {
+    37 * (37 * (37 * (37 * (17 + "FileRepository".##) + name.##) + patterns.##) + configuration.##)
+  }
+  override def toString: String = {
+    "FileRepository(" + name + ", " + patterns + ", " + configuration + ")"
+  }
+  protected[this] def copy(name: String = name, patterns: sbt.librarymanagement.Patterns = patterns, configuration: sbt.librarymanagement.FileConfiguration = configuration): FileRepository = {
+    new FileRepository(name, patterns, configuration)
+  }
+  def withName(name: String): FileRepository = {
+    copy(name = name)
+  }
+  def withPatterns(patterns: sbt.librarymanagement.Patterns): FileRepository = {
+    copy(patterns = patterns)
+  }
+  def withConfiguration(configuration: sbt.librarymanagement.FileConfiguration): FileRepository = {
+    copy(configuration = configuration)
+  }
+}
+object FileRepository {
+  def apply(name: String, configuration: sbt.librarymanagement.FileConfiguration, patterns: sbt.librarymanagement.Patterns) =
+  new FileRepository(name, patterns, configuration)
+  def apply(name: String, patterns: sbt.librarymanagement.Patterns, configuration: sbt.librarymanagement.FileConfiguration): FileRepository = new FileRepository(name, patterns, configuration)
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/FileRepositoryFormats.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/FileRepositoryFormats.scala
@ -0,0 +1,31 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait FileRepositoryFormats { self: sbt.librarymanagement.PatternsFormats with sbt.librarymanagement.FileConfigurationFormats with sjsonnew.BasicJsonProtocol =>
+implicit lazy val FileRepositoryFormat: JsonFormat[sbt.librarymanagement.FileRepository] = new JsonFormat[sbt.librarymanagement.FileRepository] {
+  override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.FileRepository = {
+    jsOpt match {
+      case Some(js) =>
+      unbuilder.beginObject(js)
+      val name = unbuilder.readField[String]("name")
+      val patterns = unbuilder.readField[sbt.librarymanagement.Patterns]("patterns")
+      val configuration = unbuilder.readField[sbt.librarymanagement.FileConfiguration]("configuration")
+      unbuilder.endObject()
+      sbt.librarymanagement.FileRepository(name, patterns, configuration)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.librarymanagement.FileRepository, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("name", obj.name)
+    builder.addField("patterns", obj.patterns)
+    builder.addField("configuration", obj.configuration)
+    builder.endObject()
+  }
+}
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/Full.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/Full.scala
@ -0,0 +1,43 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+/**
+ * Cross-versions a module with the result of
+ * prepending `prefix` and appending `suffix` to the full version.
+ * For example, if `prefix = "foo_"` and `suffix = "_bar"` and the full version is "2.12.1",
+ * the module is cross-versioned with "foo_2.12.1_bar".
+ */
+final class Full private (
+  val prefix: String,
+  val suffix: String) extends sbt.librarymanagement.CrossVersion() with Serializable {
+  
+  private def this() = this("", "")
+  
+  override def equals(o: Any): Boolean = o match {
+    case x: Full => (this.prefix == x.prefix) && (this.suffix == x.suffix)
+    case _ => false
+  }
+  override def hashCode: Int = {
+    37 * (37 * (37 * (17 + "Full".##) + prefix.##) + suffix.##)
+  }
+  override def toString: String = {
+    "Full(" + prefix + ", " + suffix + ")"
+  }
+  protected[this] def copy(prefix: String = prefix, suffix: String = suffix): Full = {
+    new Full(prefix, suffix)
+  }
+  def withPrefix(prefix: String): Full = {
+    copy(prefix = prefix)
+  }
+  def withSuffix(suffix: String): Full = {
+    copy(suffix = suffix)
+  }
+}
+object Full {
+  
+  def apply(): Full = new Full("", "")
+  def apply(prefix: String, suffix: String): Full = new Full(prefix, suffix)
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/FullFormats.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/FullFormats.scala
@ -0,0 +1,29 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait FullFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val FullFormat: JsonFormat[sbt.librarymanagement.Full] = new JsonFormat[sbt.librarymanagement.Full] {
+  override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.Full = {
+    jsOpt match {
+      case Some(js) =>
+      unbuilder.beginObject(js)
+      val prefix = unbuilder.readField[String]("prefix")
+      val suffix = unbuilder.readField[String]("suffix")
+      unbuilder.endObject()
+      sbt.librarymanagement.Full(prefix, suffix)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.librarymanagement.Full, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("prefix", obj.prefix)
+    builder.addField("suffix", obj.suffix)
+    builder.endObject()
+  }
+}
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/InclExclRule.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/InclExclRule.scala
@ -0,0 +1,58 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+/**
+ * Defines a rule to either:
+ * <ul>
+ * <li>Exclude unwanted dependencies pulled in transitively by a module, or to</li>
+ * <li>Include and merge artifacts coming from the ModuleDescriptor if "dependencyArtifacts" are also provided.</li>
+ * </ul>
+ * The use case that is applied depends on the parameter name which it is passed to, but the
+ * filter has the same fields in both cases.
+ */
+final class InclExclRule private (
+  val organization: String,
+  val name: String,
+  val artifact: String,
+  val configurations: Vector[String],
+  val crossVersion: sbt.librarymanagement.CrossVersion) extends Serializable {
+  
+  private def this() = this("*", "*", "*", Vector.empty, sbt.librarymanagement.Disabled())
+  
+  override def equals(o: Any): Boolean = o match {
+    case x: InclExclRule => (this.organization == x.organization) && (this.name == x.name) && (this.artifact == x.artifact) && (this.configurations == x.configurations) && (this.crossVersion == x.crossVersion)
+    case _ => false
+  }
+  override def hashCode: Int = {
+    37 * (37 * (37 * (37 * (37 * (37 * (17 + "InclExclRule".##) + organization.##) + name.##) + artifact.##) + configurations.##) + crossVersion.##)
+  }
+  override def toString: String = {
+    "InclExclRule(" + organization + ", " + name + ", " + artifact + ", " + configurations + ", " + crossVersion + ")"
+  }
+  protected[this] def copy(organization: String = organization, name: String = name, artifact: String = artifact, configurations: Vector[String] = configurations, crossVersion: sbt.librarymanagement.CrossVersion = crossVersion): InclExclRule = {
+    new InclExclRule(organization, name, artifact, configurations, crossVersion)
+  }
+  def withOrganization(organization: String): InclExclRule = {
+    copy(organization = organization)
+  }
+  def withName(name: String): InclExclRule = {
+    copy(name = name)
+  }
+  def withArtifact(artifact: String): InclExclRule = {
+    copy(artifact = artifact)
+  }
+  def withConfigurations(configurations: Vector[String]): InclExclRule = {
+    copy(configurations = configurations)
+  }
+  def withCrossVersion(crossVersion: sbt.librarymanagement.CrossVersion): InclExclRule = {
+    copy(crossVersion = crossVersion)
+  }
+}
+object InclExclRule extends sbt.librarymanagement.InclExclRuleFunctions {
+  
+  def apply(): InclExclRule = new InclExclRule("*", "*", "*", Vector.empty, sbt.librarymanagement.Disabled())
+  def apply(organization: String, name: String, artifact: String, configurations: Vector[String], crossVersion: sbt.librarymanagement.CrossVersion): InclExclRule = new InclExclRule(organization, name, artifact, configurations, crossVersion)
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/InclExclRuleFormats.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/InclExclRuleFormats.scala
@ -0,0 +1,35 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait InclExclRuleFormats { self: sbt.librarymanagement.CrossVersionFormats with sjsonnew.BasicJsonProtocol =>
+implicit lazy val InclExclRuleFormat: JsonFormat[sbt.librarymanagement.InclExclRule] = new JsonFormat[sbt.librarymanagement.InclExclRule] {
+  override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.InclExclRule = {
+    jsOpt match {
+      case Some(js) =>
+      unbuilder.beginObject(js)
+      val organization = unbuilder.readField[String]("organization")
+      val name = unbuilder.readField[String]("name")
+      val artifact = unbuilder.readField[String]("artifact")
+      val configurations = unbuilder.readField[Vector[String]]("configurations")
+      val crossVersion = unbuilder.readField[sbt.librarymanagement.CrossVersion]("crossVersion")
+      unbuilder.endObject()
+      sbt.librarymanagement.InclExclRule(organization, name, artifact, configurations, crossVersion)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.librarymanagement.InclExclRule, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("organization", obj.organization)
+    builder.addField("name", obj.name)
+    builder.addField("artifact", obj.artifact)
+    builder.addField("configurations", obj.configurations)
+    builder.addField("crossVersion", obj.crossVersion)
+    builder.endObject()
+  }
+}
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/InlineConfigurationFormats.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/InlineConfigurationFormats.scala
@ -0,0 +1,47 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait InlineConfigurationFormats { self: sbt.librarymanagement.IvyScalaFormats with sbt.librarymanagement.ModuleIDFormats with sbt.librarymanagement.ModuleInfoFormats with sbt.librarymanagement.InclExclRuleFormats with sbt.internal.librarymanagement.formats.NodeSeqFormat with sbt.librarymanagement.ConfigurationFormats with sbt.librarymanagement.ConflictManagerFormats with sjsonnew.BasicJsonProtocol =>
+implicit lazy val InlineConfigurationFormat: JsonFormat[sbt.internal.librarymanagement.InlineConfiguration] = new JsonFormat[sbt.internal.librarymanagement.InlineConfiguration] {
+  override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.librarymanagement.InlineConfiguration = {
+    jsOpt match {
+      case Some(js) =>
+      unbuilder.beginObject(js)
+      val validate = unbuilder.readField[Boolean]("validate")
+      val ivyScala = unbuilder.readField[Option[sbt.librarymanagement.IvyScala]]("ivyScala")
+      val module = unbuilder.readField[sbt.librarymanagement.ModuleID]("module")
+      val moduleInfo = unbuilder.readField[sbt.librarymanagement.ModuleInfo]("moduleInfo")
+      val dependencies = unbuilder.readField[Vector[sbt.librarymanagement.ModuleID]]("dependencies")
+      val overrides = unbuilder.readField[Set[sbt.librarymanagement.ModuleID]]("overrides")
+      val excludes = unbuilder.readField[Vector[sbt.librarymanagement.InclExclRule]]("excludes")
+      val ivyXML = unbuilder.readField[scala.xml.NodeSeq]("ivyXML")
+      val configurations = unbuilder.readField[Vector[sbt.librarymanagement.Configuration]]("configurations")
+      val defaultConfiguration = unbuilder.readField[Option[sbt.librarymanagement.Configuration]]("defaultConfiguration")
+      val conflictManager = unbuilder.readField[sbt.librarymanagement.ConflictManager]("conflictManager")
+      unbuilder.endObject()
+      sbt.internal.librarymanagement.InlineConfiguration(validate, ivyScala, module, moduleInfo, dependencies, overrides, excludes, ivyXML, configurations, defaultConfiguration, conflictManager)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.librarymanagement.InlineConfiguration, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("validate", obj.validate)
+    builder.addField("ivyScala", obj.ivyScala)
+    builder.addField("module", obj.module)
+    builder.addField("moduleInfo", obj.moduleInfo)
+    builder.addField("dependencies", obj.dependencies)
+    builder.addField("overrides", obj.overrides)
+    builder.addField("excludes", obj.excludes)
+    builder.addField("ivyXML", obj.ivyXML)
+    builder.addField("configurations", obj.configurations)
+    builder.addField("defaultConfiguration", obj.defaultConfiguration)
+    builder.addField("conflictManager", obj.conflictManager)
+    builder.endObject()
+  }
+}
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/InlineIvyConfigurationFormats.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/InlineIvyConfigurationFormats.scala
@ -0,0 +1,47 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait InlineIvyConfigurationFormats { self: sbt.internal.librarymanagement.formats.GlobalLockFormat with sbt.internal.librarymanagement.formats.LoggerFormat with sbt.internal.librarymanagement.formats.UpdateOptionsFormat with sbt.librarymanagement.IvyPathsFormats with sbt.librarymanagement.ResolverFormats with sbt.librarymanagement.ModuleConfigurationFormats with sjsonnew.BasicJsonProtocol =>
+implicit lazy val InlineIvyConfigurationFormat: JsonFormat[sbt.internal.librarymanagement.InlineIvyConfiguration] = new JsonFormat[sbt.internal.librarymanagement.InlineIvyConfiguration] {
+  override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.librarymanagement.InlineIvyConfiguration = {
+    jsOpt match {
+      case Some(js) =>
+      unbuilder.beginObject(js)
+      val lock = unbuilder.readField[Option[xsbti.GlobalLock]]("lock")
+      val baseDirectory = unbuilder.readField[java.io.File]("baseDirectory")
+      val log = unbuilder.readField[xsbti.Logger]("log")
+      val updateOptions = unbuilder.readField[sbt.librarymanagement.UpdateOptions]("updateOptions")
+      val paths = unbuilder.readField[sbt.internal.librarymanagement.IvyPaths]("paths")
+      val resolvers = unbuilder.readField[Vector[sbt.librarymanagement.Resolver]]("resolvers")
+      val otherResolvers = unbuilder.readField[Vector[sbt.librarymanagement.Resolver]]("otherResolvers")
+      val moduleConfigurations = unbuilder.readField[Vector[sbt.librarymanagement.ModuleConfiguration]]("moduleConfigurations")
+      val checksums = unbuilder.readField[Vector[String]]("checksums")
+      val managedChecksums = unbuilder.readField[Boolean]("managedChecksums")
+      val resolutionCacheDir = unbuilder.readField[Option[java.io.File]]("resolutionCacheDir")
+      unbuilder.endObject()
+      sbt.internal.librarymanagement.InlineIvyConfiguration(lock, baseDirectory, log, updateOptions, paths, resolvers, otherResolvers, moduleConfigurations, checksums, managedChecksums, resolutionCacheDir)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.librarymanagement.InlineIvyConfiguration, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("lock", obj.lock)
+    builder.addField("baseDirectory", obj.baseDirectory)
+    builder.addField("log", obj.log)
+    builder.addField("updateOptions", obj.updateOptions)
+    builder.addField("paths", obj.paths)
+    builder.addField("resolvers", obj.resolvers)
+    builder.addField("otherResolvers", obj.otherResolvers)
+    builder.addField("moduleConfigurations", obj.moduleConfigurations)
+    builder.addField("checksums", obj.checksums)
+    builder.addField("managedChecksums", obj.managedChecksums)
+    builder.addField("resolutionCacheDir", obj.resolutionCacheDir)
+    builder.endObject()
+  }
+}
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/IvyConfigurationFormats.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/IvyConfigurationFormats.scala
@ -0,0 +1,11 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+
+import _root_.sjsonnew.JsonFormat
+trait IvyConfigurationFormats { self: sbt.internal.librarymanagement.formats.GlobalLockFormat with sbt.internal.librarymanagement.formats.LoggerFormat with sbt.internal.librarymanagement.formats.UpdateOptionsFormat with sbt.librarymanagement.IvyPathsFormats with sbt.librarymanagement.ResolverFormats with sbt.librarymanagement.ModuleConfigurationFormats with sjsonnew.BasicJsonProtocol with sbt.librarymanagement.InlineIvyConfigurationFormats with sbt.librarymanagement.ExternalIvyConfigurationFormats =>
+implicit lazy val IvyConfigurationFormat: JsonFormat[sbt.internal.librarymanagement.IvyConfiguration] = flatUnionFormat2[sbt.internal.librarymanagement.IvyConfiguration, sbt.internal.librarymanagement.InlineIvyConfiguration, sbt.internal.librarymanagement.ExternalIvyConfiguration]("type")
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/IvyFileConfiguration.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/IvyFileConfiguration.scala
@ -0,0 +1,48 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+final class IvyFileConfiguration private (
+  validate: Boolean,
+  ivyScala: Option[sbt.librarymanagement.IvyScala],
+  val file: java.io.File,
+  val autoScalaTools: Boolean) extends sbt.librarymanagement.ModuleSettings(validate, ivyScala) with Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = o match {
+    case x: IvyFileConfiguration => (this.validate == x.validate) && (this.ivyScala == x.ivyScala) && (this.file == x.file) && (this.autoScalaTools == x.autoScalaTools)
+    case _ => false
+  }
+  override def hashCode: Int = {
+    37 * (37 * (37 * (37 * (37 * (17 + "IvyFileConfiguration".##) + validate.##) + ivyScala.##) + file.##) + autoScalaTools.##)
+  }
+  override def toString: String = {
+    "IvyFileConfiguration(" + validate + ", " + ivyScala + ", " + file + ", " + autoScalaTools + ")"
+  }
+  protected[this] def copy(validate: Boolean = validate, ivyScala: Option[sbt.librarymanagement.IvyScala] = ivyScala, file: java.io.File = file, autoScalaTools: Boolean = autoScalaTools): IvyFileConfiguration = {
+    new IvyFileConfiguration(validate, ivyScala, file, autoScalaTools)
+  }
+  def withValidate(validate: Boolean): IvyFileConfiguration = {
+    copy(validate = validate)
+  }
+  def withIvyScala(ivyScala: Option[sbt.librarymanagement.IvyScala]): IvyFileConfiguration = {
+    copy(ivyScala = ivyScala)
+  }
+  def withIvyScala(ivyScala: sbt.librarymanagement.IvyScala): IvyFileConfiguration = {
+    copy(ivyScala = Option(ivyScala))
+  }
+  def withFile(file: java.io.File): IvyFileConfiguration = {
+    copy(file = file)
+  }
+  def withAutoScalaTools(autoScalaTools: Boolean): IvyFileConfiguration = {
+    copy(autoScalaTools = autoScalaTools)
+  }
+}
+object IvyFileConfiguration {
+  
+  def apply(validate: Boolean, ivyScala: Option[sbt.librarymanagement.IvyScala], file: java.io.File, autoScalaTools: Boolean): IvyFileConfiguration = new IvyFileConfiguration(validate, ivyScala, file, autoScalaTools)
+  def apply(validate: Boolean, ivyScala: sbt.librarymanagement.IvyScala, file: java.io.File, autoScalaTools: Boolean): IvyFileConfiguration = new IvyFileConfiguration(validate, Option(ivyScala), file, autoScalaTools)
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/IvyFileConfigurationFormats.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/IvyFileConfigurationFormats.scala
@ -0,0 +1,33 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait IvyFileConfigurationFormats { self: sbt.librarymanagement.IvyScalaFormats with sjsonnew.BasicJsonProtocol =>
+implicit lazy val IvyFileConfigurationFormat: JsonFormat[sbt.librarymanagement.IvyFileConfiguration] = new JsonFormat[sbt.librarymanagement.IvyFileConfiguration] {
+  override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.IvyFileConfiguration = {
+    jsOpt match {
+      case Some(js) =>
+      unbuilder.beginObject(js)
+      val validate = unbuilder.readField[Boolean]("validate")
+      val ivyScala = unbuilder.readField[Option[sbt.librarymanagement.IvyScala]]("ivyScala")
+      val file = unbuilder.readField[java.io.File]("file")
+      val autoScalaTools = unbuilder.readField[Boolean]("autoScalaTools")
+      unbuilder.endObject()
+      sbt.librarymanagement.IvyFileConfiguration(validate, ivyScala, file, autoScalaTools)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.librarymanagement.IvyFileConfiguration, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("validate", obj.validate)
+    builder.addField("ivyScala", obj.ivyScala)
+    builder.addField("file", obj.file)
+    builder.addField("autoScalaTools", obj.autoScalaTools)
+    builder.endObject()
+  }
+}
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/IvyPathsFormats.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/IvyPathsFormats.scala
@ -0,0 +1,29 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait IvyPathsFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val IvyPathsFormat: JsonFormat[sbt.internal.librarymanagement.IvyPaths] = new JsonFormat[sbt.internal.librarymanagement.IvyPaths] {
+  override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.librarymanagement.IvyPaths = {
+    jsOpt match {
+      case Some(js) =>
+      unbuilder.beginObject(js)
+      val baseDirectory = unbuilder.readField[java.io.File]("baseDirectory")
+      val ivyHome = unbuilder.readField[Option[java.io.File]]("ivyHome")
+      unbuilder.endObject()
+      sbt.internal.librarymanagement.IvyPaths(baseDirectory, ivyHome)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.librarymanagement.IvyPaths, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("baseDirectory", obj.baseDirectory)
+    builder.addField("ivyHome", obj.ivyHome)
+    builder.endObject()
+  }
+}
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/IvyScala.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/IvyScala.scala
@ -0,0 +1,61 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+final class IvyScala private (
+  val scalaFullVersion: String,
+  val scalaBinaryVersion: String,
+  val configurations: Vector[sbt.librarymanagement.Configuration],
+  val checkExplicit: Boolean,
+  val filterImplicit: Boolean,
+  val overrideScalaVersion: Boolean,
+  val scalaOrganization: String,
+  val scalaArtifacts: scala.Vector[String]) extends Serializable {
+  
+  private def this(scalaFullVersion: String, scalaBinaryVersion: String, configurations: Vector[sbt.librarymanagement.Configuration], checkExplicit: Boolean, filterImplicit: Boolean, overrideScalaVersion: Boolean) = this(scalaFullVersion, scalaBinaryVersion, configurations, checkExplicit, filterImplicit, overrideScalaVersion, sbt.librarymanagement.ScalaArtifacts.Organization, sbt.librarymanagement.ScalaArtifacts.Artifacts)
+  
+  override def equals(o: Any): Boolean = o match {
+    case x: IvyScala => (this.scalaFullVersion == x.scalaFullVersion) && (this.scalaBinaryVersion == x.scalaBinaryVersion) && (this.configurations == x.configurations) && (this.checkExplicit == x.checkExplicit) && (this.filterImplicit == x.filterImplicit) && (this.overrideScalaVersion == x.overrideScalaVersion) && (this.scalaOrganization == x.scalaOrganization) && (this.scalaArtifacts == x.scalaArtifacts)
+    case _ => false
+  }
+  override def hashCode: Int = {
+    37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (17 + "IvyScala".##) + scalaFullVersion.##) + scalaBinaryVersion.##) + configurations.##) + checkExplicit.##) + filterImplicit.##) + overrideScalaVersion.##) + scalaOrganization.##) + scalaArtifacts.##)
+  }
+  override def toString: String = {
+    "IvyScala(" + scalaFullVersion + ", " + scalaBinaryVersion + ", " + configurations + ", " + checkExplicit + ", " + filterImplicit + ", " + overrideScalaVersion + ", " + scalaOrganization + ", " + scalaArtifacts + ")"
+  }
+  protected[this] def copy(scalaFullVersion: String = scalaFullVersion, scalaBinaryVersion: String = scalaBinaryVersion, configurations: Vector[sbt.librarymanagement.Configuration] = configurations, checkExplicit: Boolean = checkExplicit, filterImplicit: Boolean = filterImplicit, overrideScalaVersion: Boolean = overrideScalaVersion, scalaOrganization: String = scalaOrganization, scalaArtifacts: scala.Vector[String] = scalaArtifacts): IvyScala = {
+    new IvyScala(scalaFullVersion, scalaBinaryVersion, configurations, checkExplicit, filterImplicit, overrideScalaVersion, scalaOrganization, scalaArtifacts)
+  }
+  def withScalaFullVersion(scalaFullVersion: String): IvyScala = {
+    copy(scalaFullVersion = scalaFullVersion)
+  }
+  def withScalaBinaryVersion(scalaBinaryVersion: String): IvyScala = {
+    copy(scalaBinaryVersion = scalaBinaryVersion)
+  }
+  def withConfigurations(configurations: Vector[sbt.librarymanagement.Configuration]): IvyScala = {
+    copy(configurations = configurations)
+  }
+  def withCheckExplicit(checkExplicit: Boolean): IvyScala = {
+    copy(checkExplicit = checkExplicit)
+  }
+  def withFilterImplicit(filterImplicit: Boolean): IvyScala = {
+    copy(filterImplicit = filterImplicit)
+  }
+  def withOverrideScalaVersion(overrideScalaVersion: Boolean): IvyScala = {
+    copy(overrideScalaVersion = overrideScalaVersion)
+  }
+  def withScalaOrganization(scalaOrganization: String): IvyScala = {
+    copy(scalaOrganization = scalaOrganization)
+  }
+  def withScalaArtifacts(scalaArtifacts: scala.Vector[String]): IvyScala = {
+    copy(scalaArtifacts = scalaArtifacts)
+  }
+}
+object IvyScala extends sbt.librarymanagement.IvyScalaFunctions {
+  
+  def apply(scalaFullVersion: String, scalaBinaryVersion: String, configurations: Vector[sbt.librarymanagement.Configuration], checkExplicit: Boolean, filterImplicit: Boolean, overrideScalaVersion: Boolean): IvyScala = new IvyScala(scalaFullVersion, scalaBinaryVersion, configurations, checkExplicit, filterImplicit, overrideScalaVersion, sbt.librarymanagement.ScalaArtifacts.Organization, sbt.librarymanagement.ScalaArtifacts.Artifacts)
+  def apply(scalaFullVersion: String, scalaBinaryVersion: String, configurations: Vector[sbt.librarymanagement.Configuration], checkExplicit: Boolean, filterImplicit: Boolean, overrideScalaVersion: Boolean, scalaOrganization: String, scalaArtifacts: scala.Vector[String]): IvyScala = new IvyScala(scalaFullVersion, scalaBinaryVersion, configurations, checkExplicit, filterImplicit, overrideScalaVersion, scalaOrganization, scalaArtifacts)
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/IvyScalaFormats.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/IvyScalaFormats.scala
@ -0,0 +1,41 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait IvyScalaFormats { self: sbt.librarymanagement.ConfigurationFormats with sjsonnew.BasicJsonProtocol =>
+implicit lazy val IvyScalaFormat: JsonFormat[sbt.librarymanagement.IvyScala] = new JsonFormat[sbt.librarymanagement.IvyScala] {
+  override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.IvyScala = {
+    jsOpt match {
+      case Some(js) =>
+      unbuilder.beginObject(js)
+      val scalaFullVersion = unbuilder.readField[String]("scalaFullVersion")
+      val scalaBinaryVersion = unbuilder.readField[String]("scalaBinaryVersion")
+      val configurations = unbuilder.readField[Vector[sbt.librarymanagement.Configuration]]("configurations")
+      val checkExplicit = unbuilder.readField[Boolean]("checkExplicit")
+      val filterImplicit = unbuilder.readField[Boolean]("filterImplicit")
+      val overrideScalaVersion = unbuilder.readField[Boolean]("overrideScalaVersion")
+      val scalaOrganization = unbuilder.readField[String]("scalaOrganization")
+      val scalaArtifacts = unbuilder.readField[scala.Vector[String]]("scalaArtifacts")
+      unbuilder.endObject()
+      sbt.librarymanagement.IvyScala(scalaFullVersion, scalaBinaryVersion, configurations, checkExplicit, filterImplicit, overrideScalaVersion, scalaOrganization, scalaArtifacts)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.librarymanagement.IvyScala, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("scalaFullVersion", obj.scalaFullVersion)
+    builder.addField("scalaBinaryVersion", obj.scalaBinaryVersion)
+    builder.addField("configurations", obj.configurations)
+    builder.addField("checkExplicit", obj.checkExplicit)
+    builder.addField("filterImplicit", obj.filterImplicit)
+    builder.addField("overrideScalaVersion", obj.overrideScalaVersion)
+    builder.addField("scalaOrganization", obj.scalaOrganization)
+    builder.addField("scalaArtifacts", obj.scalaArtifacts)
+    builder.endObject()
+  }
+}
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/KeyFileAuthentication.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/KeyFileAuthentication.scala
@ -0,0 +1,44 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+final class KeyFileAuthentication private (
+  val user: String,
+  val keyfile: java.io.File,
+  val password: Option[String]) extends sbt.librarymanagement.SshAuthentication() with Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = o match {
+    case x: KeyFileAuthentication => (this.user == x.user) && (this.keyfile == x.keyfile) && (this.password == x.password)
+    case _ => false
+  }
+  override def hashCode: Int = {
+    37 * (37 * (37 * (37 * (17 + "KeyFileAuthentication".##) + user.##) + keyfile.##) + password.##)
+  }
+  override def toString: String = {
+    "KeyFileAuthentication(" + user + ", " + keyfile + ", " + password + ")"
+  }
+  protected[this] def copy(user: String = user, keyfile: java.io.File = keyfile, password: Option[String] = password): KeyFileAuthentication = {
+    new KeyFileAuthentication(user, keyfile, password)
+  }
+  def withUser(user: String): KeyFileAuthentication = {
+    copy(user = user)
+  }
+  def withKeyfile(keyfile: java.io.File): KeyFileAuthentication = {
+    copy(keyfile = keyfile)
+  }
+  def withPassword(password: Option[String]): KeyFileAuthentication = {
+    copy(password = password)
+  }
+  def withPassword(password: String): KeyFileAuthentication = {
+    copy(password = Option(password))
+  }
+}
+object KeyFileAuthentication {
+  
+  def apply(user: String, keyfile: java.io.File, password: Option[String]): KeyFileAuthentication = new KeyFileAuthentication(user, keyfile, password)
+  def apply(user: String, keyfile: java.io.File, password: String): KeyFileAuthentication = new KeyFileAuthentication(user, keyfile, Option(password))
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/KeyFileAuthenticationFormats.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/KeyFileAuthenticationFormats.scala
@ -0,0 +1,31 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait KeyFileAuthenticationFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val KeyFileAuthenticationFormat: JsonFormat[sbt.librarymanagement.KeyFileAuthentication] = new JsonFormat[sbt.librarymanagement.KeyFileAuthentication] {
+  override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.KeyFileAuthentication = {
+    jsOpt match {
+      case Some(js) =>
+      unbuilder.beginObject(js)
+      val user = unbuilder.readField[String]("user")
+      val keyfile = unbuilder.readField[java.io.File]("keyfile")
+      val password = unbuilder.readField[Option[String]]("password")
+      unbuilder.endObject()
+      sbt.librarymanagement.KeyFileAuthentication(user, keyfile, password)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.librarymanagement.KeyFileAuthentication, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("user", obj.user)
+    builder.addField("keyfile", obj.keyfile)
+    builder.addField("password", obj.password)
+    builder.endObject()
+  }
+}
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/LibraryManagementCodec.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/LibraryManagementCodec.scala
@ -0,0 +1,66 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+trait LibraryManagementCodec extends sjsonnew.BasicJsonProtocol
+  with sbt.librarymanagement.ConfigurationFormats
+  with sbt.librarymanagement.ChecksumFormats
+  with sbt.librarymanagement.ArtifactFormats
+  with sbt.librarymanagement.ArtifactTypeFilterFormats
+  with sbt.librarymanagement.DisabledFormats
+  with sbt.librarymanagement.BinaryFormats
+  with sbt.librarymanagement.ConstantFormats
+  with sbt.librarymanagement.PatchFormats
+  with sbt.librarymanagement.FullFormats
+  with sbt.librarymanagement.CrossVersionFormats
+  with sbt.librarymanagement.InclExclRuleFormats
+  with sbt.librarymanagement.ModuleIDFormats
+  with sbt.librarymanagement.CallerFormats
+  with sbt.librarymanagement.ModuleReportFormats
+  with sbt.librarymanagement.OrganizationArtifactReportFormats
+  with sbt.librarymanagement.ConfigurationReportFormats
+  with sbt.librarymanagement.ConflictManagerFormats
+  with sbt.librarymanagement.DeveloperFormats
+  with sbt.librarymanagement.FileConfigurationFormats
+  with sbt.librarymanagement.IvyScalaFormats
+  with sbt.librarymanagement.ChainedResolverFormats
+  with sbt.librarymanagement.MavenRepoFormats
+  with sbt.librarymanagement.MavenCacheFormats
+  with sbt.librarymanagement.PatternsFormats
+  with sbt.librarymanagement.FileRepositoryFormats
+  with sbt.librarymanagement.URLRepositoryFormats
+  with sbt.librarymanagement.PasswordAuthenticationFormats
+  with sbt.librarymanagement.KeyFileAuthenticationFormats
+  with sbt.librarymanagement.SshAuthenticationFormats
+  with sbt.librarymanagement.SshConnectionFormats
+  with sbt.librarymanagement.SshRepositoryFormats
+  with sbt.librarymanagement.SftpRepositoryFormats
+  with sbt.librarymanagement.ResolverFormats
+  with sbt.librarymanagement.ModuleConfigurationFormats
+  with sbt.librarymanagement.ScmInfoFormats
+  with sbt.librarymanagement.ModuleInfoFormats
+  with sbt.librarymanagement.IvyFileConfigurationFormats
+  with sbt.librarymanagement.PomConfigurationFormats
+  with sbt.internal.librarymanagement.formats.NodeSeqFormat
+  with sbt.librarymanagement.InlineConfigurationFormats
+  with sbt.librarymanagement.ModuleSettingsFormats
+  with sbt.librarymanagement.MavenRepositoryFormats
+  with sbt.librarymanagement.PatternsBasedRepositoryFormats
+  with sbt.librarymanagement.SshBasedRepositoryFormats
+  with sbt.librarymanagement.RetrieveConfigurationFormats
+  with sbt.librarymanagement.UpdateLoggingFormats
+  with sbt.librarymanagement.UpdateConfigurationFormats
+  with sbt.librarymanagement.UpdateStatsFormats
+  with sbt.librarymanagement.UpdateReportFormats
+  with sbt.librarymanagement.ConfigurationReportLiteFormats
+  with sbt.internal.librarymanagement.formats.GlobalLockFormat
+  with sbt.internal.librarymanagement.formats.LoggerFormat
+  with sbt.internal.librarymanagement.formats.UpdateOptionsFormat
+  with sbt.librarymanagement.IvyPathsFormats
+  with sbt.librarymanagement.InlineIvyConfigurationFormats
+  with sbt.librarymanagement.ExternalIvyConfigurationFormats
+  with sbt.librarymanagement.IvyConfigurationFormats
+  with sbt.librarymanagement.UpdateReportLiteFormats
+object LibraryManagementCodec extends LibraryManagementCodec
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/MavenCache.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/MavenCache.scala
@ -0,0 +1,50 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+/**
+ * An instance of maven CACHE directory.  You cannot treat a cache directory the same as a a remote repository because
+ * the metadata is different (see Aether ML discussion).
+ */
+final class MavenCache private (
+  name: String,
+  root: String,
+  localIfFile: Boolean,
+  val rootFile: java.io.File) extends sbt.librarymanagement.MavenRepository(name, root, localIfFile) with Serializable {
+  def this(name: String, rootFile: java.io.File) = this(name, rootFile.toURI.toURL.toString, true, rootFile)
+  def isCache: Boolean = true
+  private def this(name: String, root: String, rootFile: java.io.File) = this(name, root, true, rootFile)
+  
+  override def equals(o: Any): Boolean = o match {
+    case x: MavenCache => (this.name == x.name) && (this.root == x.root) && (this.localIfFile == x.localIfFile) && (this.rootFile == x.rootFile)
+    case _ => false
+  }
+  override def hashCode: Int = {
+    37 * (37 * (37 * (37 * (37 * (17 + "MavenCache".##) + name.##) + root.##) + localIfFile.##) + rootFile.##)
+  }
+  override def toString: String = {
+    s"cache:$name: ${rootFile.getAbsolutePath}"
+  }
+  protected[this] def copy(name: String = name, root: String = root, localIfFile: Boolean = localIfFile, rootFile: java.io.File = rootFile): MavenCache = {
+    new MavenCache(name, root, localIfFile, rootFile)
+  }
+  def withName(name: String): MavenCache = {
+    copy(name = name)
+  }
+  def withRoot(root: String): MavenCache = {
+    copy(root = root)
+  }
+  def withLocalIfFile(localIfFile: Boolean): MavenCache = {
+    copy(localIfFile = localIfFile)
+  }
+  def withRootFile(rootFile: java.io.File): MavenCache = {
+    copy(rootFile = rootFile)
+  }
+}
+object MavenCache {
+  def apply(name: String, rootFile: java.io.File): MavenCache = new MavenCache(name, rootFile)
+  def apply(name: String, root: String, rootFile: java.io.File): MavenCache = new MavenCache(name, root, true, rootFile)
+  def apply(name: String, root: String, localIfFile: Boolean, rootFile: java.io.File): MavenCache = new MavenCache(name, root, localIfFile, rootFile)
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/MavenCacheFormats.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/MavenCacheFormats.scala
@ -0,0 +1,33 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait MavenCacheFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val MavenCacheFormat: JsonFormat[sbt.librarymanagement.MavenCache] = new JsonFormat[sbt.librarymanagement.MavenCache] {
+  override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.MavenCache = {
+    jsOpt match {
+      case Some(js) =>
+      unbuilder.beginObject(js)
+      val name = unbuilder.readField[String]("name")
+      val root = unbuilder.readField[String]("root")
+      val localIfFile = unbuilder.readField[Boolean]("localIfFile")
+      val rootFile = unbuilder.readField[java.io.File]("rootFile")
+      unbuilder.endObject()
+      sbt.librarymanagement.MavenCache(name, root, localIfFile, rootFile)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.librarymanagement.MavenCache, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("name", obj.name)
+    builder.addField("root", obj.root)
+    builder.addField("localIfFile", obj.localIfFile)
+    builder.addField("rootFile", obj.rootFile)
+    builder.endObject()
+  }
+}
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/MavenRepo.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/MavenRepo.scala
@ -0,0 +1,41 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+final class MavenRepo private (
+  name: String,
+  root: String,
+  localIfFile: Boolean) extends sbt.librarymanagement.MavenRepository(name, root, localIfFile) with Serializable {
+  def isCache: Boolean = false
+  private def this(name: String, root: String) = this(name, root, true)
+  
+  override def equals(o: Any): Boolean = o match {
+    case x: MavenRepo => (this.name == x.name) && (this.root == x.root) && (this.localIfFile == x.localIfFile)
+    case _ => false
+  }
+  override def hashCode: Int = {
+    37 * (37 * (37 * (37 * (17 + "MavenRepo".##) + name.##) + root.##) + localIfFile.##)
+  }
+  override def toString: String = {
+    s"$name: $root"
+  }
+  protected[this] def copy(name: String = name, root: String = root, localIfFile: Boolean = localIfFile): MavenRepo = {
+    new MavenRepo(name, root, localIfFile)
+  }
+  def withName(name: String): MavenRepo = {
+    copy(name = name)
+  }
+  def withRoot(root: String): MavenRepo = {
+    copy(root = root)
+  }
+  def withLocalIfFile(localIfFile: Boolean): MavenRepo = {
+    copy(localIfFile = localIfFile)
+  }
+}
+object MavenRepo {
+  
+  def apply(name: String, root: String): MavenRepo = new MavenRepo(name, root, true)
+  def apply(name: String, root: String, localIfFile: Boolean): MavenRepo = new MavenRepo(name, root, localIfFile)
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/MavenRepoFormats.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/MavenRepoFormats.scala
@ -0,0 +1,31 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait MavenRepoFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val MavenRepoFormat: JsonFormat[sbt.librarymanagement.MavenRepo] = new JsonFormat[sbt.librarymanagement.MavenRepo] {
+  override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.MavenRepo = {
+    jsOpt match {
+      case Some(js) =>
+      unbuilder.beginObject(js)
+      val name = unbuilder.readField[String]("name")
+      val root = unbuilder.readField[String]("root")
+      val localIfFile = unbuilder.readField[Boolean]("localIfFile")
+      unbuilder.endObject()
+      sbt.librarymanagement.MavenRepo(name, root, localIfFile)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.librarymanagement.MavenRepo, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("name", obj.name)
+    builder.addField("root", obj.root)
+    builder.addField("localIfFile", obj.localIfFile)
+    builder.endObject()
+  }
+}
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/MavenRepository.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/MavenRepository.scala
@ -0,0 +1,29 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+/** An instance of a remote maven repository.  Note:  This will use Aether/Maven to resolve artifacts. */
+abstract class MavenRepository(
+  name: String,
+  val root: String,
+  val localIfFile: Boolean) extends sbt.librarymanagement.Resolver(name) with Serializable {
+  def isCache: Boolean
+  def this(name: String, root: String) = this(name, root, true)
+  
+  
+  override def equals(o: Any): Boolean = o match {
+    case x: MavenRepository => (this.name == x.name) && (this.root == x.root) && (this.localIfFile == x.localIfFile)
+    case _ => false
+  }
+  override def hashCode: Int = {
+    37 * (37 * (37 * (37 * (17 + "MavenRepository".##) + name.##) + root.##) + localIfFile.##)
+  }
+  override def toString: String = {
+    "MavenRepository(" + name + ", " + root + ", " + localIfFile + ")"
+  }
+}
+object MavenRepository extends sbt.librarymanagement.MavenRepositoryFunctions {
+  
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/MavenRepositoryFormats.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/MavenRepositoryFormats.scala
@ -0,0 +1,11 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+
+import _root_.sjsonnew.JsonFormat
+trait MavenRepositoryFormats { self: sjsonnew.BasicJsonProtocol with sbt.librarymanagement.MavenRepoFormats with sbt.librarymanagement.MavenCacheFormats =>
+implicit lazy val MavenRepositoryFormat: JsonFormat[sbt.librarymanagement.MavenRepository] = flatUnionFormat2[sbt.librarymanagement.MavenRepository, sbt.librarymanagement.MavenRepo, sbt.librarymanagement.MavenCache]("type")
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ModuleConfiguration.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ModuleConfiguration.scala
@ -0,0 +1,45 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+final class ModuleConfiguration private (
+  val organization: String,
+  val name: String,
+  val revision: String,
+  val resolver: sbt.librarymanagement.Resolver) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = o match {
+    case x: ModuleConfiguration => (this.organization == x.organization) && (this.name == x.name) && (this.revision == x.revision) && (this.resolver == x.resolver)
+    case _ => false
+  }
+  override def hashCode: Int = {
+    37 * (37 * (37 * (37 * (37 * (17 + "ModuleConfiguration".##) + organization.##) + name.##) + revision.##) + resolver.##)
+  }
+  override def toString: String = {
+    "ModuleConfiguration(" + organization + ", " + name + ", " + revision + ", " + resolver + ")"
+  }
+  protected[this] def copy(organization: String = organization, name: String = name, revision: String = revision, resolver: sbt.librarymanagement.Resolver = resolver): ModuleConfiguration = {
+    new ModuleConfiguration(organization, name, revision, resolver)
+  }
+  def withOrganization(organization: String): ModuleConfiguration = {
+    copy(organization = organization)
+  }
+  def withName(name: String): ModuleConfiguration = {
+    copy(name = name)
+  }
+  def withRevision(revision: String): ModuleConfiguration = {
+    copy(revision = revision)
+  }
+  def withResolver(resolver: sbt.librarymanagement.Resolver): ModuleConfiguration = {
+    copy(resolver = resolver)
+  }
+}
+object ModuleConfiguration {
+  def apply(org: String, resolver: sbt.librarymanagement.Resolver): ModuleConfiguration = apply(org, "*", "*", resolver)
+  def apply(org: String, name: String, resolver: sbt.librarymanagement.Resolver): ModuleConfiguration = ModuleConfiguration(org, name, "*", resolver)
+  def apply(organization: String, name: String, revision: String, resolver: sbt.librarymanagement.Resolver): ModuleConfiguration = new ModuleConfiguration(organization, name, revision, resolver)
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ModuleConfigurationFormats.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ModuleConfigurationFormats.scala
@ -0,0 +1,33 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait ModuleConfigurationFormats { self: sbt.librarymanagement.ResolverFormats with sjsonnew.BasicJsonProtocol =>
+implicit lazy val ModuleConfigurationFormat: JsonFormat[sbt.librarymanagement.ModuleConfiguration] = new JsonFormat[sbt.librarymanagement.ModuleConfiguration] {
+  override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.ModuleConfiguration = {
+    jsOpt match {
+      case Some(js) =>
+      unbuilder.beginObject(js)
+      val organization = unbuilder.readField[String]("organization")
+      val name = unbuilder.readField[String]("name")
+      val revision = unbuilder.readField[String]("revision")
+      val resolver = unbuilder.readField[sbt.librarymanagement.Resolver]("resolver")
+      unbuilder.endObject()
+      sbt.librarymanagement.ModuleConfiguration(organization, name, revision, resolver)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.librarymanagement.ModuleConfiguration, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("organization", obj.organization)
+    builder.addField("name", obj.name)
+    builder.addField("revision", obj.revision)
+    builder.addField("resolver", obj.resolver)
+    builder.endObject()
+  }
+}
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ModuleID.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ModuleID.scala
@ -0,0 +1,81 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+final class ModuleID private (
+  val organization: String,
+  val name: String,
+  val revision: String,
+  val configurations: Option[String],
+  val isChanging: Boolean,
+  val isTransitive: Boolean,
+  val isForce: Boolean,
+  val explicitArtifacts: Vector[sbt.librarymanagement.Artifact],
+  val inclusions: Vector[sbt.librarymanagement.InclExclRule],
+  val exclusions: Vector[sbt.librarymanagement.InclExclRule],
+  val extraAttributes: Map[String, String],
+  val crossVersion: sbt.librarymanagement.CrossVersion,
+  val branchName: Option[String]) extends sbt.librarymanagement.ModuleIDExtra with Serializable {
+  
+  private def this(organization: String, name: String, revision: String) = this(organization, name, revision, None, false, true, false, Vector.empty, Vector.empty, Vector.empty, Map.empty, sbt.librarymanagement.Disabled(), None)
+  
+  override def equals(o: Any): Boolean = o match {
+    case x: ModuleID => (this.organization == x.organization) && (this.name == x.name) && (this.revision == x.revision) && (this.configurations == x.configurations) && (this.isChanging == x.isChanging) && (this.isTransitive == x.isTransitive) && (this.isForce == x.isForce) && (this.explicitArtifacts == x.explicitArtifacts) && (this.inclusions == x.inclusions) && (this.exclusions == x.exclusions) && (this.extraAttributes == x.extraAttributes) && (this.crossVersion == x.crossVersion) && (this.branchName == x.branchName)
+    case _ => false
+  }
+  override def hashCode: Int = {
+    37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (17 + "ModuleID".##) + organization.##) + name.##) + revision.##) + configurations.##) + isChanging.##) + isTransitive.##) + isForce.##) + explicitArtifacts.##) + inclusions.##) + exclusions.##) + extraAttributes.##) + crossVersion.##) + branchName.##)
+  }
+  override def toString: String = {
+    this.toStringImpl
+  }
+  protected[this] def copy(organization: String = organization, name: String = name, revision: String = revision, configurations: Option[String] = configurations, isChanging: Boolean = isChanging, isTransitive: Boolean = isTransitive, isForce: Boolean = isForce, explicitArtifacts: Vector[sbt.librarymanagement.Artifact] = explicitArtifacts, inclusions: Vector[sbt.librarymanagement.InclExclRule] = inclusions, exclusions: Vector[sbt.librarymanagement.InclExclRule] = exclusions, extraAttributes: Map[String, String] = extraAttributes, crossVersion: sbt.librarymanagement.CrossVersion = crossVersion, branchName: Option[String] = branchName): ModuleID = {
+    new ModuleID(organization, name, revision, configurations, isChanging, isTransitive, isForce, explicitArtifacts, inclusions, exclusions, extraAttributes, crossVersion, branchName)
+  }
+  def withOrganization(organization: String): ModuleID = {
+    copy(organization = organization)
+  }
+  def withName(name: String): ModuleID = {
+    copy(name = name)
+  }
+  def withRevision(revision: String): ModuleID = {
+    copy(revision = revision)
+  }
+  def withConfigurations(configurations: Option[String]): ModuleID = {
+    copy(configurations = configurations)
+  }
+  def withIsChanging(isChanging: Boolean): ModuleID = {
+    copy(isChanging = isChanging)
+  }
+  def withIsTransitive(isTransitive: Boolean): ModuleID = {
+    copy(isTransitive = isTransitive)
+  }
+  def withIsForce(isForce: Boolean): ModuleID = {
+    copy(isForce = isForce)
+  }
+  def withExplicitArtifacts(explicitArtifacts: Vector[sbt.librarymanagement.Artifact]): ModuleID = {
+    copy(explicitArtifacts = explicitArtifacts)
+  }
+  def withInclusions(inclusions: Vector[sbt.librarymanagement.InclExclRule]): ModuleID = {
+    copy(inclusions = inclusions)
+  }
+  def withExclusions(exclusions: Vector[sbt.librarymanagement.InclExclRule]): ModuleID = {
+    copy(exclusions = exclusions)
+  }
+  def withExtraAttributes(extraAttributes: Map[String, String]): ModuleID = {
+    copy(extraAttributes = extraAttributes)
+  }
+  def withCrossVersion(crossVersion: sbt.librarymanagement.CrossVersion): ModuleID = {
+    copy(crossVersion = crossVersion)
+  }
+  def withBranchName(branchName: Option[String]): ModuleID = {
+    copy(branchName = branchName)
+  }
+}
+object ModuleID extends sbt.librarymanagement.ModuleIDFunctions {
+  
+  def apply(organization: String, name: String, revision: String): ModuleID = new ModuleID(organization, name, revision, None, false, true, false, Vector.empty, Vector.empty, Vector.empty, Map.empty, sbt.librarymanagement.Disabled(), None)
+  def apply(organization: String, name: String, revision: String, configurations: Option[String], isChanging: Boolean, isTransitive: Boolean, isForce: Boolean, explicitArtifacts: Vector[sbt.librarymanagement.Artifact], inclusions: Vector[sbt.librarymanagement.InclExclRule], exclusions: Vector[sbt.librarymanagement.InclExclRule], extraAttributes: Map[String, String], crossVersion: sbt.librarymanagement.CrossVersion, branchName: Option[String]): ModuleID = new ModuleID(organization, name, revision, configurations, isChanging, isTransitive, isForce, explicitArtifacts, inclusions, exclusions, extraAttributes, crossVersion, branchName)
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ModuleIDFormats.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ModuleIDFormats.scala
@ -0,0 +1,51 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait ModuleIDFormats { self: sbt.librarymanagement.ArtifactFormats with sbt.librarymanagement.InclExclRuleFormats with sbt.librarymanagement.CrossVersionFormats with sjsonnew.BasicJsonProtocol =>
+implicit lazy val ModuleIDFormat: JsonFormat[sbt.librarymanagement.ModuleID] = new JsonFormat[sbt.librarymanagement.ModuleID] {
+  override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.ModuleID = {
+    jsOpt match {
+      case Some(js) =>
+      unbuilder.beginObject(js)
+      val organization = unbuilder.readField[String]("organization")
+      val name = unbuilder.readField[String]("name")
+      val revision = unbuilder.readField[String]("revision")
+      val configurations = unbuilder.readField[Option[String]]("configurations")
+      val isChanging = unbuilder.readField[Boolean]("isChanging")
+      val isTransitive = unbuilder.readField[Boolean]("isTransitive")
+      val isForce = unbuilder.readField[Boolean]("isForce")
+      val explicitArtifacts = unbuilder.readField[Vector[sbt.librarymanagement.Artifact]]("explicitArtifacts")
+      val inclusions = unbuilder.readField[Vector[sbt.librarymanagement.InclExclRule]]("inclusions")
+      val exclusions = unbuilder.readField[Vector[sbt.librarymanagement.InclExclRule]]("exclusions")
+      val extraAttributes = unbuilder.readField[Map[String, String]]("extraAttributes")
+      val crossVersion = unbuilder.readField[sbt.librarymanagement.CrossVersion]("crossVersion")
+      val branchName = unbuilder.readField[Option[String]]("branchName")
+      unbuilder.endObject()
+      sbt.librarymanagement.ModuleID(organization, name, revision, configurations, isChanging, isTransitive, isForce, explicitArtifacts, inclusions, exclusions, extraAttributes, crossVersion, branchName)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.librarymanagement.ModuleID, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("organization", obj.organization)
+    builder.addField("name", obj.name)
+    builder.addField("revision", obj.revision)
+    builder.addField("configurations", obj.configurations)
+    builder.addField("isChanging", obj.isChanging)
+    builder.addField("isTransitive", obj.isTransitive)
+    builder.addField("isForce", obj.isForce)
+    builder.addField("explicitArtifacts", obj.explicitArtifacts)
+    builder.addField("inclusions", obj.inclusions)
+    builder.addField("exclusions", obj.exclusions)
+    builder.addField("extraAttributes", obj.extraAttributes)
+    builder.addField("crossVersion", obj.crossVersion)
+    builder.addField("branchName", obj.branchName)
+    builder.endObject()
+  }
+}
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ModuleInfo.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ModuleInfo.scala
@ -0,0 +1,66 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+/** Additional information about a project module */
+final class ModuleInfo private (
+  val nameFormal: String,
+  val description: String,
+  val homepage: Option[java.net.URL],
+  val startYear: Option[Int],
+  val licenses: Vector[scala.Tuple2[String, java.net.URL]],
+  val organizationName: String,
+  val organizationHomepage: Option[java.net.URL],
+  val scmInfo: Option[sbt.librarymanagement.ScmInfo],
+  val developers: Vector[sbt.librarymanagement.Developer]) extends Serializable {
+  
+  private def this(nameFormal: String) = this(nameFormal, "", None, None, Vector.empty, "", None, None, Vector.empty)
+  
+  override def equals(o: Any): Boolean = o match {
+    case x: ModuleInfo => (this.nameFormal == x.nameFormal) && (this.description == x.description) && (this.homepage == x.homepage) && (this.startYear == x.startYear) && (this.licenses == x.licenses) && (this.organizationName == x.organizationName) && (this.organizationHomepage == x.organizationHomepage) && (this.scmInfo == x.scmInfo) && (this.developers == x.developers)
+    case _ => false
+  }
+  override def hashCode: Int = {
+    37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (17 + "ModuleInfo".##) + nameFormal.##) + description.##) + homepage.##) + startYear.##) + licenses.##) + organizationName.##) + organizationHomepage.##) + scmInfo.##) + developers.##)
+  }
+  override def toString: String = {
+    "ModuleInfo(" + nameFormal + ", " + description + ", " + homepage + ", " + startYear + ", " + licenses + ", " + organizationName + ", " + organizationHomepage + ", " + scmInfo + ", " + developers + ")"
+  }
+  protected[this] def copy(nameFormal: String = nameFormal, description: String = description, homepage: Option[java.net.URL] = homepage, startYear: Option[Int] = startYear, licenses: Vector[scala.Tuple2[String, java.net.URL]] = licenses, organizationName: String = organizationName, organizationHomepage: Option[java.net.URL] = organizationHomepage, scmInfo: Option[sbt.librarymanagement.ScmInfo] = scmInfo, developers: Vector[sbt.librarymanagement.Developer] = developers): ModuleInfo = {
+    new ModuleInfo(nameFormal, description, homepage, startYear, licenses, organizationName, organizationHomepage, scmInfo, developers)
+  }
+  def withNameFormal(nameFormal: String): ModuleInfo = {
+    copy(nameFormal = nameFormal)
+  }
+  def withDescription(description: String): ModuleInfo = {
+    copy(description = description)
+  }
+  def withHomepage(homepage: Option[java.net.URL]): ModuleInfo = {
+    copy(homepage = homepage)
+  }
+  def withStartYear(startYear: Option[Int]): ModuleInfo = {
+    copy(startYear = startYear)
+  }
+  def withLicenses(licenses: Vector[scala.Tuple2[String, java.net.URL]]): ModuleInfo = {
+    copy(licenses = licenses)
+  }
+  def withOrganizationName(organizationName: String): ModuleInfo = {
+    copy(organizationName = organizationName)
+  }
+  def withOrganizationHomepage(organizationHomepage: Option[java.net.URL]): ModuleInfo = {
+    copy(organizationHomepage = organizationHomepage)
+  }
+  def withScmInfo(scmInfo: Option[sbt.librarymanagement.ScmInfo]): ModuleInfo = {
+    copy(scmInfo = scmInfo)
+  }
+  def withDevelopers(developers: Vector[sbt.librarymanagement.Developer]): ModuleInfo = {
+    copy(developers = developers)
+  }
+}
+object ModuleInfo {
+  
+  def apply(nameFormal: String): ModuleInfo = new ModuleInfo(nameFormal, "", None, None, Vector.empty, "", None, None, Vector.empty)
+  def apply(nameFormal: String, description: String, homepage: Option[java.net.URL], startYear: Option[Int], licenses: Vector[scala.Tuple2[String, java.net.URL]], organizationName: String, organizationHomepage: Option[java.net.URL], scmInfo: Option[sbt.librarymanagement.ScmInfo], developers: Vector[sbt.librarymanagement.Developer]): ModuleInfo = new ModuleInfo(nameFormal, description, homepage, startYear, licenses, organizationName, organizationHomepage, scmInfo, developers)
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ModuleInfoFormats.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ModuleInfoFormats.scala
@ -0,0 +1,43 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait ModuleInfoFormats { self: sbt.librarymanagement.ScmInfoFormats with sbt.librarymanagement.DeveloperFormats with sjsonnew.BasicJsonProtocol =>
+implicit lazy val ModuleInfoFormat: JsonFormat[sbt.librarymanagement.ModuleInfo] = new JsonFormat[sbt.librarymanagement.ModuleInfo] {
+  override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.ModuleInfo = {
+    jsOpt match {
+      case Some(js) =>
+      unbuilder.beginObject(js)
+      val nameFormal = unbuilder.readField[String]("nameFormal")
+      val description = unbuilder.readField[String]("description")
+      val homepage = unbuilder.readField[Option[java.net.URL]]("homepage")
+      val startYear = unbuilder.readField[Option[Int]]("startYear")
+      val licenses = unbuilder.readField[Vector[scala.Tuple2[String, java.net.URL]]]("licenses")
+      val organizationName = unbuilder.readField[String]("organizationName")
+      val organizationHomepage = unbuilder.readField[Option[java.net.URL]]("organizationHomepage")
+      val scmInfo = unbuilder.readField[Option[sbt.librarymanagement.ScmInfo]]("scmInfo")
+      val developers = unbuilder.readField[Vector[sbt.librarymanagement.Developer]]("developers")
+      unbuilder.endObject()
+      sbt.librarymanagement.ModuleInfo(nameFormal, description, homepage, startYear, licenses, organizationName, organizationHomepage, scmInfo, developers)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.librarymanagement.ModuleInfo, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("nameFormal", obj.nameFormal)
+    builder.addField("description", obj.description)
+    builder.addField("homepage", obj.homepage)
+    builder.addField("startYear", obj.startYear)
+    builder.addField("licenses", obj.licenses)
+    builder.addField("organizationName", obj.organizationName)
+    builder.addField("organizationHomepage", obj.organizationHomepage)
+    builder.addField("scmInfo", obj.scmInfo)
+    builder.addField("developers", obj.developers)
+    builder.endObject()
+  }
+}
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ModuleReport.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ModuleReport.scala
@ -0,0 +1,106 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+/**
+ * Provides information about the resolution of a module.
+ * This information is in the context of a specific configuration.
+ */
+final class ModuleReport private (
+  val module: sbt.librarymanagement.ModuleID,
+  val artifacts: Vector[scala.Tuple2[sbt.librarymanagement.Artifact, java.io.File]],
+  val missingArtifacts: Vector[sbt.librarymanagement.Artifact],
+  val status: Option[String],
+  val publicationDate: Option[java.util.Calendar],
+  val resolver: Option[String],
+  val artifactResolver: Option[String],
+  val evicted: Boolean,
+  val evictedData: Option[String],
+  val evictedReason: Option[String],
+  val problem: Option[String],
+  val homepage: Option[String],
+  val extraAttributes: Map[String, String],
+  val isDefault: Option[Boolean],
+  val branch: Option[String],
+  val configurations: Vector[String],
+  val licenses: Vector[scala.Tuple2[String, Option[String]]],
+  val callers: Vector[sbt.librarymanagement.Caller]) extends sbt.librarymanagement.ModuleReportExtra with Serializable {
+  
+  private def this(module: sbt.librarymanagement.ModuleID, artifacts: Vector[scala.Tuple2[sbt.librarymanagement.Artifact, java.io.File]], missingArtifacts: Vector[sbt.librarymanagement.Artifact]) = this(module, artifacts, missingArtifacts, None, None, None, None, false, None, None, None, None, Map.empty, None, None, Vector.empty, Vector.empty, Vector.empty)
+  
+  override def equals(o: Any): Boolean = o match {
+    case x: ModuleReport => (this.module == x.module) && (this.artifacts == x.artifacts) && (this.missingArtifacts == x.missingArtifacts) && (this.status == x.status) && (this.publicationDate == x.publicationDate) && (this.resolver == x.resolver) && (this.artifactResolver == x.artifactResolver) && (this.evicted == x.evicted) && (this.evictedData == x.evictedData) && (this.evictedReason == x.evictedReason) && (this.problem == x.problem) && (this.homepage == x.homepage) && (this.extraAttributes == x.extraAttributes) && (this.isDefault == x.isDefault) && (this.branch == x.branch) && (this.configurations == x.configurations) && (this.licenses == x.licenses) && (this.callers == x.callers)
+    case _ => false
+  }
+  override def hashCode: Int = {
+    37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (37 * (17 + "ModuleReport".##) + module.##) + artifacts.##) + missingArtifacts.##) + status.##) + publicationDate.##) + resolver.##) + artifactResolver.##) + evicted.##) + evictedData.##) + evictedReason.##) + problem.##) + homepage.##) + extraAttributes.##) + isDefault.##) + branch.##) + configurations.##) + licenses.##) + callers.##)
+  }
+  override def toString: String = {
+    s"\t\t$module: " +
+    (if (arts.size <= 1) "" else "\n\t\t\t") + arts.mkString("\n\t\t\t") + "\n"
+  }
+  protected[this] def copy(module: sbt.librarymanagement.ModuleID = module, artifacts: Vector[scala.Tuple2[sbt.librarymanagement.Artifact, java.io.File]] = artifacts, missingArtifacts: Vector[sbt.librarymanagement.Artifact] = missingArtifacts, status: Option[String] = status, publicationDate: Option[java.util.Calendar] = publicationDate, resolver: Option[String] = resolver, artifactResolver: Option[String] = artifactResolver, evicted: Boolean = evicted, evictedData: Option[String] = evictedData, evictedReason: Option[String] = evictedReason, problem: Option[String] = problem, homepage: Option[String] = homepage, extraAttributes: Map[String, String] = extraAttributes, isDefault: Option[Boolean] = isDefault, branch: Option[String] = branch, configurations: Vector[String] = configurations, licenses: Vector[scala.Tuple2[String, Option[String]]] = licenses, callers: Vector[sbt.librarymanagement.Caller] = callers): ModuleReport = {
+    new ModuleReport(module, artifacts, missingArtifacts, status, publicationDate, resolver, artifactResolver, evicted, evictedData, evictedReason, problem, homepage, extraAttributes, isDefault, branch, configurations, licenses, callers)
+  }
+  def withModule(module: sbt.librarymanagement.ModuleID): ModuleReport = {
+    copy(module = module)
+  }
+  def withArtifacts(artifacts: Vector[scala.Tuple2[sbt.librarymanagement.Artifact, java.io.File]]): ModuleReport = {
+    copy(artifacts = artifacts)
+  }
+  def withMissingArtifacts(missingArtifacts: Vector[sbt.librarymanagement.Artifact]): ModuleReport = {
+    copy(missingArtifacts = missingArtifacts)
+  }
+  def withStatus(status: Option[String]): ModuleReport = {
+    copy(status = status)
+  }
+  def withPublicationDate(publicationDate: Option[java.util.Calendar]): ModuleReport = {
+    copy(publicationDate = publicationDate)
+  }
+  def withResolver(resolver: Option[String]): ModuleReport = {
+    copy(resolver = resolver)
+  }
+  def withArtifactResolver(artifactResolver: Option[String]): ModuleReport = {
+    copy(artifactResolver = artifactResolver)
+  }
+  def withEvicted(evicted: Boolean): ModuleReport = {
+    copy(evicted = evicted)
+  }
+  def withEvictedData(evictedData: Option[String]): ModuleReport = {
+    copy(evictedData = evictedData)
+  }
+  def withEvictedReason(evictedReason: Option[String]): ModuleReport = {
+    copy(evictedReason = evictedReason)
+  }
+  def withProblem(problem: Option[String]): ModuleReport = {
+    copy(problem = problem)
+  }
+  def withHomepage(homepage: Option[String]): ModuleReport = {
+    copy(homepage = homepage)
+  }
+  def withExtraAttributes(extraAttributes: Map[String, String]): ModuleReport = {
+    copy(extraAttributes = extraAttributes)
+  }
+  def withIsDefault(isDefault: Option[Boolean]): ModuleReport = {
+    copy(isDefault = isDefault)
+  }
+  def withBranch(branch: Option[String]): ModuleReport = {
+    copy(branch = branch)
+  }
+  def withConfigurations(configurations: Vector[String]): ModuleReport = {
+    copy(configurations = configurations)
+  }
+  def withLicenses(licenses: Vector[scala.Tuple2[String, Option[String]]]): ModuleReport = {
+    copy(licenses = licenses)
+  }
+  def withCallers(callers: Vector[sbt.librarymanagement.Caller]): ModuleReport = {
+    copy(callers = callers)
+  }
+}
+object ModuleReport {
+  
+  def apply(module: sbt.librarymanagement.ModuleID, artifacts: Vector[scala.Tuple2[sbt.librarymanagement.Artifact, java.io.File]], missingArtifacts: Vector[sbt.librarymanagement.Artifact]): ModuleReport = new ModuleReport(module, artifacts, missingArtifacts, None, None, None, None, false, None, None, None, None, Map.empty, None, None, Vector.empty, Vector.empty, Vector.empty)
+  def apply(module: sbt.librarymanagement.ModuleID, artifacts: Vector[scala.Tuple2[sbt.librarymanagement.Artifact, java.io.File]], missingArtifacts: Vector[sbt.librarymanagement.Artifact], status: Option[String], publicationDate: Option[java.util.Calendar], resolver: Option[String], artifactResolver: Option[String], evicted: Boolean, evictedData: Option[String], evictedReason: Option[String], problem: Option[String], homepage: Option[String], extraAttributes: Map[String, String], isDefault: Option[Boolean], branch: Option[String], configurations: Vector[String], licenses: Vector[scala.Tuple2[String, Option[String]]], callers: Vector[sbt.librarymanagement.Caller]): ModuleReport = new ModuleReport(module, artifacts, missingArtifacts, status, publicationDate, resolver, artifactResolver, evicted, evictedData, evictedReason, problem, homepage, extraAttributes, isDefault, branch, configurations, licenses, callers)
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ModuleReportFormats.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ModuleReportFormats.scala
@ -0,0 +1,61 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait ModuleReportFormats { self: sbt.librarymanagement.ModuleIDFormats with sbt.librarymanagement.ArtifactFormats with sbt.librarymanagement.CallerFormats with sjsonnew.BasicJsonProtocol =>
+implicit lazy val ModuleReportFormat: JsonFormat[sbt.librarymanagement.ModuleReport] = new JsonFormat[sbt.librarymanagement.ModuleReport] {
+  override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.ModuleReport = {
+    jsOpt match {
+      case Some(js) =>
+      unbuilder.beginObject(js)
+      val module = unbuilder.readField[sbt.librarymanagement.ModuleID]("module")
+      val artifacts = unbuilder.readField[Vector[scala.Tuple2[sbt.librarymanagement.Artifact, java.io.File]]]("artifacts")
+      val missingArtifacts = unbuilder.readField[Vector[sbt.librarymanagement.Artifact]]("missingArtifacts")
+      val status = unbuilder.readField[Option[String]]("status")
+      val publicationDate = unbuilder.readField[Option[java.util.Calendar]]("publicationDate")
+      val resolver = unbuilder.readField[Option[String]]("resolver")
+      val artifactResolver = unbuilder.readField[Option[String]]("artifactResolver")
+      val evicted = unbuilder.readField[Boolean]("evicted")
+      val evictedData = unbuilder.readField[Option[String]]("evictedData")
+      val evictedReason = unbuilder.readField[Option[String]]("evictedReason")
+      val problem = unbuilder.readField[Option[String]]("problem")
+      val homepage = unbuilder.readField[Option[String]]("homepage")
+      val extraAttributes = unbuilder.readField[Map[String, String]]("extraAttributes")
+      val isDefault = unbuilder.readField[Option[Boolean]]("isDefault")
+      val branch = unbuilder.readField[Option[String]]("branch")
+      val configurations = unbuilder.readField[Vector[String]]("configurations")
+      val licenses = unbuilder.readField[Vector[scala.Tuple2[String, Option[String]]]]("licenses")
+      val callers = unbuilder.readField[Vector[sbt.librarymanagement.Caller]]("callers")
+      unbuilder.endObject()
+      sbt.librarymanagement.ModuleReport(module, artifacts, missingArtifacts, status, publicationDate, resolver, artifactResolver, evicted, evictedData, evictedReason, problem, homepage, extraAttributes, isDefault, branch, configurations, licenses, callers)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.librarymanagement.ModuleReport, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("module", obj.module)
+    builder.addField("artifacts", obj.artifacts)
+    builder.addField("missingArtifacts", obj.missingArtifacts)
+    builder.addField("status", obj.status)
+    builder.addField("publicationDate", obj.publicationDate)
+    builder.addField("resolver", obj.resolver)
+    builder.addField("artifactResolver", obj.artifactResolver)
+    builder.addField("evicted", obj.evicted)
+    builder.addField("evictedData", obj.evictedData)
+    builder.addField("evictedReason", obj.evictedReason)
+    builder.addField("problem", obj.problem)
+    builder.addField("homepage", obj.homepage)
+    builder.addField("extraAttributes", obj.extraAttributes)
+    builder.addField("isDefault", obj.isDefault)
+    builder.addField("branch", obj.branch)
+    builder.addField("configurations", obj.configurations)
+    builder.addField("licenses", obj.licenses)
+    builder.addField("callers", obj.callers)
+    builder.endObject()
+  }
+}
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ModuleSettings.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ModuleSettings.scala
@ -0,0 +1,27 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+abstract class ModuleSettings(
+  val validate: Boolean,
+  val ivyScala: Option[sbt.librarymanagement.IvyScala]) extends Serializable {
+  
+  
+  
+  
+  override def equals(o: Any): Boolean = o match {
+    case x: ModuleSettings => (this.validate == x.validate) && (this.ivyScala == x.ivyScala)
+    case _ => false
+  }
+  override def hashCode: Int = {
+    37 * (37 * (37 * (17 + "ModuleSettings".##) + validate.##) + ivyScala.##)
+  }
+  override def toString: String = {
+    "ModuleSettings(" + validate + ", " + ivyScala + ")"
+  }
+}
+object ModuleSettings {
+  
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ModuleSettingsFormats.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ModuleSettingsFormats.scala
@ -0,0 +1,11 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+
+import _root_.sjsonnew.JsonFormat
+trait ModuleSettingsFormats { self: sbt.librarymanagement.IvyScalaFormats with sjsonnew.BasicJsonProtocol with sbt.librarymanagement.IvyFileConfigurationFormats with sbt.librarymanagement.PomConfigurationFormats with sbt.librarymanagement.ModuleIDFormats with sbt.librarymanagement.ModuleInfoFormats with sbt.librarymanagement.InclExclRuleFormats with sbt.internal.librarymanagement.formats.NodeSeqFormat with sbt.librarymanagement.ConfigurationFormats with sbt.librarymanagement.ConflictManagerFormats with sbt.librarymanagement.InlineConfigurationFormats =>
+implicit lazy val ModuleSettingsFormat: JsonFormat[sbt.librarymanagement.ModuleSettings] = flatUnionFormat3[sbt.librarymanagement.ModuleSettings, sbt.librarymanagement.IvyFileConfiguration, sbt.librarymanagement.PomConfiguration, sbt.internal.librarymanagement.InlineConfiguration]("type")
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/OrganizationArtifactReport.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/OrganizationArtifactReport.scala
@ -0,0 +1,51 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+/**
+ * OrganizationArtifactReport represents an organization+name entry in Ivy resolution report.
+ * In sbt's terminology, "module" consists of organization, name, and version.
+ * In Ivy's, "module" means just organization and name, and the one including version numbers
+ * are called revisions.
+ * 
+ * A sequence of OrganizationArtifactReport called details is newly added to ConfigurationReport, replacing evicted.
+ * (Note old evicted was just a seq of ModuleIDs).
+ * OrganizationArtifactReport groups the ModuleReport of both winners and evicted reports by their organization and name,
+ * which can be used to calculate detailed eviction warning etc.
+ */
+final class OrganizationArtifactReport private (
+  val organization: String,
+  val name: String,
+  val modules: Vector[sbt.librarymanagement.ModuleReport]) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = o match {
+    case x: OrganizationArtifactReport => (this.organization == x.organization) && (this.name == x.name) && (this.modules == x.modules)
+    case _ => false
+  }
+  override def hashCode: Int = {
+    37 * (37 * (37 * (37 * (17 + "OrganizationArtifactReport".##) + organization.##) + name.##) + modules.##)
+  }
+  override def toString: String = {
+    "OrganizationArtifactReport(" + organization + ", " + name + ", " + modules + ")"
+  }
+  protected[this] def copy(organization: String = organization, name: String = name, modules: Vector[sbt.librarymanagement.ModuleReport] = modules): OrganizationArtifactReport = {
+    new OrganizationArtifactReport(organization, name, modules)
+  }
+  def withOrganization(organization: String): OrganizationArtifactReport = {
+    copy(organization = organization)
+  }
+  def withName(name: String): OrganizationArtifactReport = {
+    copy(name = name)
+  }
+  def withModules(modules: Vector[sbt.librarymanagement.ModuleReport]): OrganizationArtifactReport = {
+    copy(modules = modules)
+  }
+}
+object OrganizationArtifactReport {
+  
+  def apply(organization: String, name: String, modules: Vector[sbt.librarymanagement.ModuleReport]): OrganizationArtifactReport = new OrganizationArtifactReport(organization, name, modules)
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/OrganizationArtifactReportFormats.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/OrganizationArtifactReportFormats.scala
@ -0,0 +1,31 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait OrganizationArtifactReportFormats { self: sbt.librarymanagement.ModuleReportFormats with sjsonnew.BasicJsonProtocol =>
+implicit lazy val OrganizationArtifactReportFormat: JsonFormat[sbt.librarymanagement.OrganizationArtifactReport] = new JsonFormat[sbt.librarymanagement.OrganizationArtifactReport] {
+  override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.OrganizationArtifactReport = {
+    jsOpt match {
+      case Some(js) =>
+      unbuilder.beginObject(js)
+      val organization = unbuilder.readField[String]("organization")
+      val name = unbuilder.readField[String]("name")
+      val modules = unbuilder.readField[Vector[sbt.librarymanagement.ModuleReport]]("modules")
+      unbuilder.endObject()
+      sbt.librarymanagement.OrganizationArtifactReport(organization, name, modules)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.librarymanagement.OrganizationArtifactReport, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("organization", obj.organization)
+    builder.addField("name", obj.name)
+    builder.addField("modules", obj.modules)
+    builder.endObject()
+  }
+}
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/PasswordAuthentication.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/PasswordAuthentication.scala
@ -0,0 +1,40 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+final class PasswordAuthentication private (
+  val user: String,
+  val password: Option[String]) extends sbt.librarymanagement.SshAuthentication() with Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = o match {
+    case x: PasswordAuthentication => (this.user == x.user) && (this.password == x.password)
+    case _ => false
+  }
+  override def hashCode: Int = {
+    37 * (37 * (37 * (17 + "PasswordAuthentication".##) + user.##) + password.##)
+  }
+  override def toString: String = {
+    "PasswordAuthentication(" + user + ", " + password + ")"
+  }
+  protected[this] def copy(user: String = user, password: Option[String] = password): PasswordAuthentication = {
+    new PasswordAuthentication(user, password)
+  }
+  def withUser(user: String): PasswordAuthentication = {
+    copy(user = user)
+  }
+  def withPassword(password: Option[String]): PasswordAuthentication = {
+    copy(password = password)
+  }
+  def withPassword(password: String): PasswordAuthentication = {
+    copy(password = Option(password))
+  }
+}
+object PasswordAuthentication {
+  
+  def apply(user: String, password: Option[String]): PasswordAuthentication = new PasswordAuthentication(user, password)
+  def apply(user: String, password: String): PasswordAuthentication = new PasswordAuthentication(user, Option(password))
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/PasswordAuthenticationFormats.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/PasswordAuthenticationFormats.scala
@ -0,0 +1,29 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait PasswordAuthenticationFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val PasswordAuthenticationFormat: JsonFormat[sbt.librarymanagement.PasswordAuthentication] = new JsonFormat[sbt.librarymanagement.PasswordAuthentication] {
+  override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.PasswordAuthentication = {
+    jsOpt match {
+      case Some(js) =>
+      unbuilder.beginObject(js)
+      val user = unbuilder.readField[String]("user")
+      val password = unbuilder.readField[Option[String]]("password")
+      unbuilder.endObject()
+      sbt.librarymanagement.PasswordAuthentication(user, password)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.librarymanagement.PasswordAuthentication, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("user", obj.user)
+    builder.addField("password", obj.password)
+    builder.endObject()
+  }
+}
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/Patch.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/Patch.scala
@ -0,0 +1,33 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+/**
+ * Cross-versions a module by stripping off -bin-suffix.
+ * This is intended for patch-version compatible alternative replacements.
+ */
+final class Patch private () extends sbt.librarymanagement.CrossVersion() with Serializable {
+
+
+
+override def equals(o: Any): Boolean = o match {
+  case x: Patch => true
+  case _ => false
+}
+override def hashCode: Int = {
+  37 * (17 + "Patch".##)
+}
+override def toString: String = {
+  "Patch()"
+}
+protected[this] def copy(): Patch = {
+  new Patch()
+}
+
+}
+object Patch {
+  
+  def apply(): Patch = new Patch()
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/PatchFormats.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/PatchFormats.scala
@ -0,0 +1,27 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait PatchFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val PatchFormat: JsonFormat[sbt.librarymanagement.Patch] = new JsonFormat[sbt.librarymanagement.Patch] {
+  override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.Patch = {
+    jsOpt match {
+      case Some(js) =>
+      unbuilder.beginObject(js)
+      
+      unbuilder.endObject()
+      sbt.librarymanagement.Patch()
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.librarymanagement.Patch, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    
+    builder.endObject()
+  }
+}
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/Patterns.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/Patterns.scala
@ -0,0 +1,50 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+final class Patterns private (
+  val ivyPatterns: Vector[String],
+  val artifactPatterns: Vector[String],
+  val isMavenCompatible: Boolean,
+  val descriptorOptional: Boolean,
+  val skipConsistencyCheck: Boolean) extends Serializable {
+  
+  private def this() = this(Vector.empty, Vector.empty, true, false, false)
+  
+  override def equals(o: Any): Boolean = o match {
+    case x: Patterns => (this.ivyPatterns == x.ivyPatterns) && (this.artifactPatterns == x.artifactPatterns) && (this.isMavenCompatible == x.isMavenCompatible) && (this.descriptorOptional == x.descriptorOptional) && (this.skipConsistencyCheck == x.skipConsistencyCheck)
+    case _ => false
+  }
+  override def hashCode: Int = {
+    37 * (37 * (37 * (37 * (37 * (37 * (17 + "Patterns".##) + ivyPatterns.##) + artifactPatterns.##) + isMavenCompatible.##) + descriptorOptional.##) + skipConsistencyCheck.##)
+  }
+  override def toString: String = {
+    "Patterns(ivyPatterns=%s, artifactPatterns=%s, isMavenCompatible=%s, descriptorOptional=%s, skipConsistencyCheck=%s)".format(
+    ivyPatterns, artifactPatterns, isMavenCompatible, descriptorOptional, skipConsistencyCheck)
+  }
+  protected[this] def copy(ivyPatterns: Vector[String] = ivyPatterns, artifactPatterns: Vector[String] = artifactPatterns, isMavenCompatible: Boolean = isMavenCompatible, descriptorOptional: Boolean = descriptorOptional, skipConsistencyCheck: Boolean = skipConsistencyCheck): Patterns = {
+    new Patterns(ivyPatterns, artifactPatterns, isMavenCompatible, descriptorOptional, skipConsistencyCheck)
+  }
+  def withIvyPatterns(ivyPatterns: Vector[String]): Patterns = {
+    copy(ivyPatterns = ivyPatterns)
+  }
+  def withArtifactPatterns(artifactPatterns: Vector[String]): Patterns = {
+    copy(artifactPatterns = artifactPatterns)
+  }
+  def withIsMavenCompatible(isMavenCompatible: Boolean): Patterns = {
+    copy(isMavenCompatible = isMavenCompatible)
+  }
+  def withDescriptorOptional(descriptorOptional: Boolean): Patterns = {
+    copy(descriptorOptional = descriptorOptional)
+  }
+  def withSkipConsistencyCheck(skipConsistencyCheck: Boolean): Patterns = {
+    copy(skipConsistencyCheck = skipConsistencyCheck)
+  }
+}
+object Patterns extends sbt.librarymanagement.PatternsFunctions {
+  
+  def apply(): Patterns = new Patterns(Vector.empty, Vector.empty, true, false, false)
+  def apply(ivyPatterns: Vector[String], artifactPatterns: Vector[String], isMavenCompatible: Boolean, descriptorOptional: Boolean, skipConsistencyCheck: Boolean): Patterns = new Patterns(ivyPatterns, artifactPatterns, isMavenCompatible, descriptorOptional, skipConsistencyCheck)
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/PatternsBasedRepository.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/PatternsBasedRepository.scala
@ -0,0 +1,28 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+/** sbt interface to an Ivy repository based on patterns, which is most Ivy repositories. */
+abstract class PatternsBasedRepository(
+  name: String,
+  val patterns: sbt.librarymanagement.Patterns) extends sbt.librarymanagement.Resolver(name) with Serializable {
+  
+  
+  
+  
+  override def equals(o: Any): Boolean = o match {
+    case x: PatternsBasedRepository => (this.name == x.name) && (this.patterns == x.patterns)
+    case _ => false
+  }
+  override def hashCode: Int = {
+    37 * (37 * (37 * (17 + "PatternsBasedRepository".##) + name.##) + patterns.##)
+  }
+  override def toString: String = {
+    "PatternsBasedRepository(" + name + ", " + patterns + ")"
+  }
+}
+object PatternsBasedRepository {
+  
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/PatternsBasedRepositoryFormats.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/PatternsBasedRepositoryFormats.scala
@ -0,0 +1,11 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+
+import _root_.sjsonnew.JsonFormat
+trait PatternsBasedRepositoryFormats { self: sbt.librarymanagement.PatternsFormats with sbt.librarymanagement.FileConfigurationFormats with sjsonnew.BasicJsonProtocol with sbt.librarymanagement.FileRepositoryFormats with sbt.librarymanagement.URLRepositoryFormats with sbt.librarymanagement.SshConnectionFormats with sbt.librarymanagement.SshRepositoryFormats with sbt.librarymanagement.SftpRepositoryFormats =>
+implicit lazy val PatternsBasedRepositoryFormat: JsonFormat[sbt.librarymanagement.PatternsBasedRepository] = flatUnionFormat4[sbt.librarymanagement.PatternsBasedRepository, sbt.librarymanagement.FileRepository, sbt.librarymanagement.URLRepository, sbt.librarymanagement.SshRepository, sbt.librarymanagement.SftpRepository]("type")
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/PatternsFormats.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/PatternsFormats.scala
@ -0,0 +1,35 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait PatternsFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val PatternsFormat: JsonFormat[sbt.librarymanagement.Patterns] = new JsonFormat[sbt.librarymanagement.Patterns] {
+  override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.Patterns = {
+    jsOpt match {
+      case Some(js) =>
+      unbuilder.beginObject(js)
+      val ivyPatterns = unbuilder.readField[Vector[String]]("ivyPatterns")
+      val artifactPatterns = unbuilder.readField[Vector[String]]("artifactPatterns")
+      val isMavenCompatible = unbuilder.readField[Boolean]("isMavenCompatible")
+      val descriptorOptional = unbuilder.readField[Boolean]("descriptorOptional")
+      val skipConsistencyCheck = unbuilder.readField[Boolean]("skipConsistencyCheck")
+      unbuilder.endObject()
+      sbt.librarymanagement.Patterns(ivyPatterns, artifactPatterns, isMavenCompatible, descriptorOptional, skipConsistencyCheck)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.librarymanagement.Patterns, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("ivyPatterns", obj.ivyPatterns)
+    builder.addField("artifactPatterns", obj.artifactPatterns)
+    builder.addField("isMavenCompatible", obj.isMavenCompatible)
+    builder.addField("descriptorOptional", obj.descriptorOptional)
+    builder.addField("skipConsistencyCheck", obj.skipConsistencyCheck)
+    builder.endObject()
+  }
+}
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/PomConfiguration.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/PomConfiguration.scala
@ -0,0 +1,48 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+final class PomConfiguration private (
+  validate: Boolean,
+  ivyScala: Option[sbt.librarymanagement.IvyScala],
+  val file: java.io.File,
+  val autoScalaTools: Boolean) extends sbt.librarymanagement.ModuleSettings(validate, ivyScala) with Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = o match {
+    case x: PomConfiguration => (this.validate == x.validate) && (this.ivyScala == x.ivyScala) && (this.file == x.file) && (this.autoScalaTools == x.autoScalaTools)
+    case _ => false
+  }
+  override def hashCode: Int = {
+    37 * (37 * (37 * (37 * (37 * (17 + "PomConfiguration".##) + validate.##) + ivyScala.##) + file.##) + autoScalaTools.##)
+  }
+  override def toString: String = {
+    "PomConfiguration(" + validate + ", " + ivyScala + ", " + file + ", " + autoScalaTools + ")"
+  }
+  protected[this] def copy(validate: Boolean = validate, ivyScala: Option[sbt.librarymanagement.IvyScala] = ivyScala, file: java.io.File = file, autoScalaTools: Boolean = autoScalaTools): PomConfiguration = {
+    new PomConfiguration(validate, ivyScala, file, autoScalaTools)
+  }
+  def withValidate(validate: Boolean): PomConfiguration = {
+    copy(validate = validate)
+  }
+  def withIvyScala(ivyScala: Option[sbt.librarymanagement.IvyScala]): PomConfiguration = {
+    copy(ivyScala = ivyScala)
+  }
+  def withIvyScala(ivyScala: sbt.librarymanagement.IvyScala): PomConfiguration = {
+    copy(ivyScala = Option(ivyScala))
+  }
+  def withFile(file: java.io.File): PomConfiguration = {
+    copy(file = file)
+  }
+  def withAutoScalaTools(autoScalaTools: Boolean): PomConfiguration = {
+    copy(autoScalaTools = autoScalaTools)
+  }
+}
+object PomConfiguration {
+  
+  def apply(validate: Boolean, ivyScala: Option[sbt.librarymanagement.IvyScala], file: java.io.File, autoScalaTools: Boolean): PomConfiguration = new PomConfiguration(validate, ivyScala, file, autoScalaTools)
+  def apply(validate: Boolean, ivyScala: sbt.librarymanagement.IvyScala, file: java.io.File, autoScalaTools: Boolean): PomConfiguration = new PomConfiguration(validate, Option(ivyScala), file, autoScalaTools)
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/PomConfigurationFormats.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/PomConfigurationFormats.scala
@ -0,0 +1,33 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait PomConfigurationFormats { self: sbt.librarymanagement.IvyScalaFormats with sjsonnew.BasicJsonProtocol =>
+implicit lazy val PomConfigurationFormat: JsonFormat[sbt.librarymanagement.PomConfiguration] = new JsonFormat[sbt.librarymanagement.PomConfiguration] {
+  override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.PomConfiguration = {
+    jsOpt match {
+      case Some(js) =>
+      unbuilder.beginObject(js)
+      val validate = unbuilder.readField[Boolean]("validate")
+      val ivyScala = unbuilder.readField[Option[sbt.librarymanagement.IvyScala]]("ivyScala")
+      val file = unbuilder.readField[java.io.File]("file")
+      val autoScalaTools = unbuilder.readField[Boolean]("autoScalaTools")
+      unbuilder.endObject()
+      sbt.librarymanagement.PomConfiguration(validate, ivyScala, file, autoScalaTools)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.librarymanagement.PomConfiguration, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("validate", obj.validate)
+    builder.addField("ivyScala", obj.ivyScala)
+    builder.addField("file", obj.file)
+    builder.addField("autoScalaTools", obj.autoScalaTools)
+    builder.endObject()
+  }
+}
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/Resolver.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/Resolver.scala
@ -0,0 +1,26 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+abstract class Resolver(
+  val name: String) extends Serializable {
+  
+  
+  
+  
+  override def equals(o: Any): Boolean = o match {
+    case x: Resolver => (this.name == x.name)
+    case _ => false
+  }
+  override def hashCode: Int = {
+    37 * (37 * (17 + "Resolver".##) + name.##)
+  }
+  override def toString: String = {
+    "Resolver(" + name + ")"
+  }
+}
+object Resolver extends sbt.librarymanagement.ResolverFunctions {
+  
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ResolverFormats.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ResolverFormats.scala
@ -0,0 +1,11 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+
+import _root_.sjsonnew.JsonFormat
+trait ResolverFormats { self: sjsonnew.BasicJsonProtocol with sbt.librarymanagement.ChainedResolverFormats with sbt.librarymanagement.MavenRepoFormats with sbt.librarymanagement.MavenCacheFormats with sbt.librarymanagement.PatternsFormats with sbt.librarymanagement.FileConfigurationFormats with sbt.librarymanagement.FileRepositoryFormats with sbt.librarymanagement.URLRepositoryFormats with sbt.librarymanagement.SshConnectionFormats with sbt.librarymanagement.SshRepositoryFormats with sbt.librarymanagement.SftpRepositoryFormats =>
+implicit lazy val ResolverFormat: JsonFormat[sbt.librarymanagement.Resolver] = flatUnionFormat7[sbt.librarymanagement.Resolver, sbt.librarymanagement.ChainedResolver, sbt.librarymanagement.MavenRepo, sbt.librarymanagement.MavenCache, sbt.librarymanagement.FileRepository, sbt.librarymanagement.URLRepository, sbt.librarymanagement.SshRepository, sbt.librarymanagement.SftpRepository]("type")
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/RetrieveConfigurationFormats.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/RetrieveConfigurationFormats.scala
@ -0,0 +1,33 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait RetrieveConfigurationFormats { self: sbt.librarymanagement.ConfigurationFormats with sjsonnew.BasicJsonProtocol =>
+implicit lazy val RetrieveConfigurationFormat: JsonFormat[sbt.internal.librarymanagement.RetrieveConfiguration] = new JsonFormat[sbt.internal.librarymanagement.RetrieveConfiguration] {
+  override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.librarymanagement.RetrieveConfiguration = {
+    jsOpt match {
+      case Some(js) =>
+      unbuilder.beginObject(js)
+      val retrieveDirectory = unbuilder.readField[java.io.File]("retrieveDirectory")
+      val outputPattern = unbuilder.readField[String]("outputPattern")
+      val sync = unbuilder.readField[Boolean]("sync")
+      val configurationsToRetrieve = unbuilder.readField[Option[Set[sbt.librarymanagement.Configuration]]]("configurationsToRetrieve")
+      unbuilder.endObject()
+      sbt.internal.librarymanagement.RetrieveConfiguration(retrieveDirectory, outputPattern, sync, configurationsToRetrieve)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.internal.librarymanagement.RetrieveConfiguration, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("retrieveDirectory", obj.retrieveDirectory)
+    builder.addField("outputPattern", obj.outputPattern)
+    builder.addField("sync", obj.sync)
+    builder.addField("configurationsToRetrieve", obj.configurationsToRetrieve)
+    builder.endObject()
+  }
+}
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ScmInfo.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ScmInfo.scala
@ -0,0 +1,46 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+/** Basic SCM information for a project module */
+final class ScmInfo private (
+  val browseUrl: java.net.URL,
+  val connection: String,
+  val devConnection: Option[String]) extends Serializable {
+  
+  private def this(browseUrl: java.net.URL, connection: String) = this(browseUrl, connection, None)
+  
+  override def equals(o: Any): Boolean = o match {
+    case x: ScmInfo => (this.browseUrl == x.browseUrl) && (this.connection == x.connection) && (this.devConnection == x.devConnection)
+    case _ => false
+  }
+  override def hashCode: Int = {
+    37 * (37 * (37 * (37 * (17 + "ScmInfo".##) + browseUrl.##) + connection.##) + devConnection.##)
+  }
+  override def toString: String = {
+    "ScmInfo(" + browseUrl + ", " + connection + ", " + devConnection + ")"
+  }
+  protected[this] def copy(browseUrl: java.net.URL = browseUrl, connection: String = connection, devConnection: Option[String] = devConnection): ScmInfo = {
+    new ScmInfo(browseUrl, connection, devConnection)
+  }
+  def withBrowseUrl(browseUrl: java.net.URL): ScmInfo = {
+    copy(browseUrl = browseUrl)
+  }
+  def withConnection(connection: String): ScmInfo = {
+    copy(connection = connection)
+  }
+  def withDevConnection(devConnection: Option[String]): ScmInfo = {
+    copy(devConnection = devConnection)
+  }
+  def withDevConnection(devConnection: String): ScmInfo = {
+    copy(devConnection = Option(devConnection))
+  }
+}
+object ScmInfo {
+  
+  def apply(browseUrl: java.net.URL, connection: String): ScmInfo = new ScmInfo(browseUrl, connection, None)
+  def apply(browseUrl: java.net.URL, connection: String, devConnection: Option[String]): ScmInfo = new ScmInfo(browseUrl, connection, devConnection)
+  def apply(browseUrl: java.net.URL, connection: String, devConnection: String): ScmInfo = new ScmInfo(browseUrl, connection, Option(devConnection))
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ScmInfoFormats.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/ScmInfoFormats.scala
@ -0,0 +1,31 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait ScmInfoFormats { self: sjsonnew.BasicJsonProtocol =>
+implicit lazy val ScmInfoFormat: JsonFormat[sbt.librarymanagement.ScmInfo] = new JsonFormat[sbt.librarymanagement.ScmInfo] {
+  override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.ScmInfo = {
+    jsOpt match {
+      case Some(js) =>
+      unbuilder.beginObject(js)
+      val browseUrl = unbuilder.readField[java.net.URL]("browseUrl")
+      val connection = unbuilder.readField[String]("connection")
+      val devConnection = unbuilder.readField[Option[String]]("devConnection")
+      unbuilder.endObject()
+      sbt.librarymanagement.ScmInfo(browseUrl, connection, devConnection)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.librarymanagement.ScmInfo, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("browseUrl", obj.browseUrl)
+    builder.addField("connection", obj.connection)
+    builder.addField("devConnection", obj.devConnection)
+    builder.endObject()
+  }
+}
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/SftpRepository.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/SftpRepository.scala
@ -0,0 +1,43 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+/** sbt interface for an Ivy repository over sftp.  More convenient construction is done using Resolver.sftp. */
+final class SftpRepository private (
+  name: String,
+  patterns: sbt.librarymanagement.Patterns,
+  connection: sbt.librarymanagement.SshConnection) extends sbt.librarymanagement.SshBasedRepository(name, patterns, connection) with sbt.librarymanagement.SftpRepositoryExtra with Serializable {
+  def this(name: String, connection: sbt.librarymanagement.SshConnection, patterns: sbt.librarymanagement.Patterns) =
+  this(name, patterns, connection)
+  
+  
+  override def equals(o: Any): Boolean = o match {
+    case x: SftpRepository => (this.name == x.name) && (this.patterns == x.patterns) && (this.connection == x.connection)
+    case _ => false
+  }
+  override def hashCode: Int = {
+    37 * (37 * (37 * (37 * (17 + "SftpRepository".##) + name.##) + patterns.##) + connection.##)
+  }
+  override def toString: String = {
+    "SftpRepository(" + name + ", " + patterns + ", " + connection + ")"
+  }
+  protected[this] def copy(name: String = name, patterns: sbt.librarymanagement.Patterns = patterns, connection: sbt.librarymanagement.SshConnection = connection): SftpRepository = {
+    new SftpRepository(name, patterns, connection)
+  }
+  def withName(name: String): SftpRepository = {
+    copy(name = name)
+  }
+  def withPatterns(patterns: sbt.librarymanagement.Patterns): SftpRepository = {
+    copy(patterns = patterns)
+  }
+  def withConnection(connection: sbt.librarymanagement.SshConnection): SftpRepository = {
+    copy(connection = connection)
+  }
+}
+object SftpRepository {
+  def apply(name: String, connection: sbt.librarymanagement.SshConnection, patterns: sbt.librarymanagement.Patterns) =
+  new SftpRepository(name, patterns, connection)
+  def apply(name: String, patterns: sbt.librarymanagement.Patterns, connection: sbt.librarymanagement.SshConnection): SftpRepository = new SftpRepository(name, patterns, connection)
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/SftpRepositoryFormats.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/SftpRepositoryFormats.scala
@ -0,0 +1,31 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait SftpRepositoryFormats { self: sbt.librarymanagement.PatternsFormats with sbt.librarymanagement.SshConnectionFormats with sjsonnew.BasicJsonProtocol =>
+implicit lazy val SftpRepositoryFormat: JsonFormat[sbt.librarymanagement.SftpRepository] = new JsonFormat[sbt.librarymanagement.SftpRepository] {
+  override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.SftpRepository = {
+    jsOpt match {
+      case Some(js) =>
+      unbuilder.beginObject(js)
+      val name = unbuilder.readField[String]("name")
+      val patterns = unbuilder.readField[sbt.librarymanagement.Patterns]("patterns")
+      val connection = unbuilder.readField[sbt.librarymanagement.SshConnection]("connection")
+      unbuilder.endObject()
+      sbt.librarymanagement.SftpRepository(name, patterns, connection)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.librarymanagement.SftpRepository, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("name", obj.name)
+    builder.addField("patterns", obj.patterns)
+    builder.addField("connection", obj.connection)
+    builder.endObject()
+  }
+}
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/SshAuthentication.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/SshAuthentication.scala
@ -0,0 +1,25 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+abstract class SshAuthentication() extends Serializable {
+
+
+
+
+override def equals(o: Any): Boolean = o match {
+  case x: SshAuthentication => true
+  case _ => false
+}
+override def hashCode: Int = {
+  37 * (17 + "SshAuthentication".##)
+}
+override def toString: String = {
+  "SshAuthentication()"
+}
+}
+object SshAuthentication {
+  
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/SshAuthenticationFormats.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/SshAuthenticationFormats.scala
@ -0,0 +1,11 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+
+import _root_.sjsonnew.JsonFormat
+trait SshAuthenticationFormats { self: sjsonnew.BasicJsonProtocol with sbt.librarymanagement.PasswordAuthenticationFormats with sbt.librarymanagement.KeyFileAuthenticationFormats =>
+implicit lazy val SshAuthenticationFormat: JsonFormat[sbt.librarymanagement.SshAuthentication] = flatUnionFormat2[sbt.librarymanagement.SshAuthentication, sbt.librarymanagement.PasswordAuthentication, sbt.librarymanagement.KeyFileAuthentication]("type")
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/SshBasedRepository.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/SshBasedRepository.scala
@ -0,0 +1,29 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+/** sbt interface for an Ivy ssh-based repository (ssh and sftp).  Requires the Jsch library.. */
+abstract class SshBasedRepository(
+  name: String,
+  patterns: sbt.librarymanagement.Patterns,
+  val connection: sbt.librarymanagement.SshConnection) extends sbt.librarymanagement.PatternsBasedRepository(name, patterns) with sbt.librarymanagement.SshBasedRepositoryExtra with Serializable {
+  
+  
+  
+  
+  override def equals(o: Any): Boolean = o match {
+    case x: SshBasedRepository => (this.name == x.name) && (this.patterns == x.patterns) && (this.connection == x.connection)
+    case _ => false
+  }
+  override def hashCode: Int = {
+    37 * (37 * (37 * (37 * (17 + "SshBasedRepository".##) + name.##) + patterns.##) + connection.##)
+  }
+  override def toString: String = {
+    "SshBasedRepository(" + name + ", " + patterns + ", " + connection + ")"
+  }
+}
+object SshBasedRepository {
+  
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/SshBasedRepositoryFormats.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/SshBasedRepositoryFormats.scala
@ -0,0 +1,11 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+
+import _root_.sjsonnew.JsonFormat
+trait SshBasedRepositoryFormats { self: sbt.librarymanagement.PatternsFormats with sbt.librarymanagement.SshConnectionFormats with sjsonnew.BasicJsonProtocol with sbt.librarymanagement.SshRepositoryFormats with sbt.librarymanagement.SftpRepositoryFormats =>
+implicit lazy val SshBasedRepositoryFormat: JsonFormat[sbt.librarymanagement.SshBasedRepository] = flatUnionFormat2[sbt.librarymanagement.SshBasedRepository, sbt.librarymanagement.SshRepository, sbt.librarymanagement.SftpRepository]("type")
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/SshConnection.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/SshConnection.scala
@ -0,0 +1,50 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+final class SshConnection private (
+  val authentication: Option[sbt.librarymanagement.SshAuthentication],
+  val hostname: Option[String],
+  val port: Option[Int]) extends Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = o match {
+    case x: SshConnection => (this.authentication == x.authentication) && (this.hostname == x.hostname) && (this.port == x.port)
+    case _ => false
+  }
+  override def hashCode: Int = {
+    37 * (37 * (37 * (37 * (17 + "SshConnection".##) + authentication.##) + hostname.##) + port.##)
+  }
+  override def toString: String = {
+    "SshConnection(" + authentication + ", " + hostname + ", " + port + ")"
+  }
+  protected[this] def copy(authentication: Option[sbt.librarymanagement.SshAuthentication] = authentication, hostname: Option[String] = hostname, port: Option[Int] = port): SshConnection = {
+    new SshConnection(authentication, hostname, port)
+  }
+  def withAuthentication(authentication: Option[sbt.librarymanagement.SshAuthentication]): SshConnection = {
+    copy(authentication = authentication)
+  }
+  def withAuthentication(authentication: sbt.librarymanagement.SshAuthentication): SshConnection = {
+    copy(authentication = Option(authentication))
+  }
+  def withHostname(hostname: Option[String]): SshConnection = {
+    copy(hostname = hostname)
+  }
+  def withHostname(hostname: String): SshConnection = {
+    copy(hostname = Option(hostname))
+  }
+  def withPort(port: Option[Int]): SshConnection = {
+    copy(port = port)
+  }
+  def withPort(port: Int): SshConnection = {
+    copy(port = Option(port))
+  }
+}
+object SshConnection {
+  
+  def apply(authentication: Option[sbt.librarymanagement.SshAuthentication], hostname: Option[String], port: Option[Int]): SshConnection = new SshConnection(authentication, hostname, port)
+  def apply(authentication: sbt.librarymanagement.SshAuthentication, hostname: String, port: Int): SshConnection = new SshConnection(Option(authentication), Option(hostname), Option(port))
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/SshConnectionFormats.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/SshConnectionFormats.scala
@ -0,0 +1,31 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait SshConnectionFormats { self: sbt.librarymanagement.SshAuthenticationFormats with sjsonnew.BasicJsonProtocol =>
+implicit lazy val SshConnectionFormat: JsonFormat[sbt.librarymanagement.SshConnection] = new JsonFormat[sbt.librarymanagement.SshConnection] {
+  override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.SshConnection = {
+    jsOpt match {
+      case Some(js) =>
+      unbuilder.beginObject(js)
+      val authentication = unbuilder.readField[Option[sbt.librarymanagement.SshAuthentication]]("authentication")
+      val hostname = unbuilder.readField[Option[String]]("hostname")
+      val port = unbuilder.readField[Option[Int]]("port")
+      unbuilder.endObject()
+      sbt.librarymanagement.SshConnection(authentication, hostname, port)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.librarymanagement.SshConnection, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("authentication", obj.authentication)
+    builder.addField("hostname", obj.hostname)
+    builder.addField("port", obj.port)
+    builder.endObject()
+  }
+}
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/SshRepository.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/SshRepository.scala
@ -0,0 +1,51 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+/** sbt interface for an Ivy repository over ssh.  More convenient construction is done using Resolver.ssh. */
+final class SshRepository private (
+  name: String,
+  patterns: sbt.librarymanagement.Patterns,
+  connection: sbt.librarymanagement.SshConnection,
+  val publishPermissions: Option[String]) extends sbt.librarymanagement.SshBasedRepository(name, patterns, connection) with sbt.librarymanagement.SshRepositoryExtra with Serializable {
+  def this(name: String, connection: sbt.librarymanagement.SshConnection, patterns: sbt.librarymanagement.Patterns, publishPermissions: Option[String]) =
+  this(name, patterns, connection, publishPermissions)
+  
+  
+  override def equals(o: Any): Boolean = o match {
+    case x: SshRepository => (this.name == x.name) && (this.patterns == x.patterns) && (this.connection == x.connection) && (this.publishPermissions == x.publishPermissions)
+    case _ => false
+  }
+  override def hashCode: Int = {
+    37 * (37 * (37 * (37 * (37 * (17 + "SshRepository".##) + name.##) + patterns.##) + connection.##) + publishPermissions.##)
+  }
+  override def toString: String = {
+    "SshRepository(" + name + ", " + patterns + ", " + connection + ", " + publishPermissions + ")"
+  }
+  protected[this] def copy(name: String = name, patterns: sbt.librarymanagement.Patterns = patterns, connection: sbt.librarymanagement.SshConnection = connection, publishPermissions: Option[String] = publishPermissions): SshRepository = {
+    new SshRepository(name, patterns, connection, publishPermissions)
+  }
+  def withName(name: String): SshRepository = {
+    copy(name = name)
+  }
+  def withPatterns(patterns: sbt.librarymanagement.Patterns): SshRepository = {
+    copy(patterns = patterns)
+  }
+  def withConnection(connection: sbt.librarymanagement.SshConnection): SshRepository = {
+    copy(connection = connection)
+  }
+  def withPublishPermissions(publishPermissions: Option[String]): SshRepository = {
+    copy(publishPermissions = publishPermissions)
+  }
+  def withPublishPermissions(publishPermissions: String): SshRepository = {
+    copy(publishPermissions = Option(publishPermissions))
+  }
+}
+object SshRepository {
+  def apply(name: String, connection: sbt.librarymanagement.SshConnection, patterns: sbt.librarymanagement.Patterns, publishPermissions: Option[String]) =
+  new SshRepository(name, patterns, connection, publishPermissions)
+  def apply(name: String, patterns: sbt.librarymanagement.Patterns, connection: sbt.librarymanagement.SshConnection, publishPermissions: Option[String]): SshRepository = new SshRepository(name, patterns, connection, publishPermissions)
+  def apply(name: String, patterns: sbt.librarymanagement.Patterns, connection: sbt.librarymanagement.SshConnection, publishPermissions: String): SshRepository = new SshRepository(name, patterns, connection, Option(publishPermissions))
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/SshRepositoryFormats.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/SshRepositoryFormats.scala
@ -0,0 +1,33 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError }
+trait SshRepositoryFormats { self: sbt.librarymanagement.PatternsFormats with sbt.librarymanagement.SshConnectionFormats with sjsonnew.BasicJsonProtocol =>
+implicit lazy val SshRepositoryFormat: JsonFormat[sbt.librarymanagement.SshRepository] = new JsonFormat[sbt.librarymanagement.SshRepository] {
+  override def read[J](jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.librarymanagement.SshRepository = {
+    jsOpt match {
+      case Some(js) =>
+      unbuilder.beginObject(js)
+      val name = unbuilder.readField[String]("name")
+      val patterns = unbuilder.readField[sbt.librarymanagement.Patterns]("patterns")
+      val connection = unbuilder.readField[sbt.librarymanagement.SshConnection]("connection")
+      val publishPermissions = unbuilder.readField[Option[String]]("publishPermissions")
+      unbuilder.endObject()
+      sbt.librarymanagement.SshRepository(name, patterns, connection, publishPermissions)
+      case None =>
+      deserializationError("Expected JsObject but found None")
+    }
+  }
+  override def write[J](obj: sbt.librarymanagement.SshRepository, builder: Builder[J]): Unit = {
+    builder.beginObject()
+    builder.addField("name", obj.name)
+    builder.addField("patterns", obj.patterns)
+    builder.addField("connection", obj.connection)
+    builder.addField("publishPermissions", obj.publishPermissions)
+    builder.endObject()
+  }
+}
+}
--- a/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/URLRepository.scala
+++ b/librarymanagement/src/main/contraband-scala/sbt/librarymanagement/URLRepository.scala
@ -0,0 +1,36 @@
+/**
+ * This code is generated using [[http://www.scala-sbt.org/contraband/ sbt-contraband]].
+ */
+
+// DO NOT EDIT MANUALLY
+package sbt.librarymanagement
+final class URLRepository private (
+  name: String,
+  patterns: sbt.librarymanagement.Patterns) extends sbt.librarymanagement.PatternsBasedRepository(name, patterns) with Serializable {
+  
+  
+  
+  override def equals(o: Any): Boolean = o match {
+    case x: URLRepository => (this.name == x.name) && (this.patterns == x.patterns)
+    case _ => false
+  }
+  override def hashCode: Int = {
+    37 * (37 * (37 * (17 + "URLRepository".##) + name.##) + patterns.##)
+  }
+  override def toString: String = {
+    "URLRepository(" + name + ", " + patterns + ")"
+  }
+  protected[this] def copy(name: String = name, patterns: sbt.librarymanagement.Patterns = patterns): URLRepository = {
+    new URLRepository(name, patterns)
+  }
+  def withName(name: String): URLRepository = {
+    copy(name = name)
+  }
+  def withPatterns(patterns: sbt.librarymanagement.Patterns): URLRepository = {
+    copy(patterns = patterns)
+  }
+}
+object URLRepository {
+  
+  def apply(name: String, patterns: sbt.librarymanagement.Patterns): URLRepository = new URLRepository(name, patterns)
+}
--- a/Show More
+++ b/Show More