/* sbt -- Simple Build Tool
 * Copyright 2009  Mark Harrah
 */
package sbt
 
/** A project that provides a classpath. */
trait trait ClasspathProject extends java.lang.Object with sbt.Project with ScalaObjectClasspathProject extends sbt.ProjectProject
{
	/** The local classpath for this project.*/
	def (sbt.Configuration)sbt.PathFinderprojectClasspath(sbt.Configurationconfig: sbt.ConfigurationConfiguration): sbt.PathFinderPathFinder
	
	/** Returns the classpath of this project and the classpaths of all dependencies for the
	* given configuration.  Specifically, this concatentates projectClasspath(config) for all
	* projects of type ClasspathProject in topologicalSort. */
	def (sbt.Configuration)sbt.PathFinderfullClasspath(sbt.Configurationconfig: sbt.ConfigurationConfiguration): sbt.PathFinderPathFinder =
		object sbt.PathPath.(=> Iterable[sbt.Path])sbt.PathFinderlazyPathFinder
		{
			val scala.collection.jcl.LinkedHashSet[sbt.Path]set = ()scala.collection.jcl.LinkedHashSet[sbt.Path]new scala.collection.jcl.scala.collection.jcl.LinkedHashSet[sbt.Path]LinkedHashSet[Path]
			for(((sbt.Project) => Unit)Unitproject <- => List[sbt.Project]topologicalSort)
			{
				sbt.Projectproject Unitmatch
				{
					Unitcase sbt.ClasspathProjectsp: sbt.ClasspathProjectClasspathProject => scala.collection.jcl.LinkedHashSet[sbt.Path]set (Iterable[sbt.Path])Unit++= sbt.ClasspathProjectsp.(sbt.Configuration)sbt.PathFinderprojectClasspath(sbt.Configurationconfig).=> scala.collection.Set[sbt.Path]get
					Unitcase _ => Unit()
				}
			}
			scala.collection.jcl.LinkedHashSet[sbt.Path]set.=> List[sbt.Path]toList
		}
}
trait trait BasicDependencyProject extends java.lang.Object with sbt.BasicManagedProject with sbt.UnmanagedClasspathProject with ScalaObjectBasicDependencyProject extends sbt.BasicManagedProjectBasicManagedProject with sbt.UnmanagedClasspathProjectUnmanagedClasspathProject
{
	/** This returns the classpath for only this project for the given configuration.*/
	def (sbt.Configuration)sbt.PathFinderprojectClasspath(sbt.Configurationconfig: sbt.ConfigurationConfiguration) = (sbt.Configuration)sbt.PathFinderfullUnmanagedClasspath(sbt.Configurationconfig) (sbt.PathFinder)sbt.PathFinder+++ (sbt.Configuration)sbt.PathFindermanagedClasspath(sbt.Configurationconfig)
}
/** A project that provides a directory in which jars can be manually managed.*/
trait trait UnmanagedClasspathProject extends java.lang.Object with sbt.ClasspathProject with ScalaObjectUnmanagedClasspathProject extends sbt.ClasspathProjectClasspathProject
{
	/** The location of the manually managed (unmanaged) dependency directory.*/
	def => sbt.PathdependencyPath: sbt.PathPath
	/** The classpath containing all jars in the unmanaged directory. */
	def => sbt.PathFinderunmanagedClasspath: sbt.PathFinderPathFinder = (sbt.PathFinder,sbt.FileFilter)sbt.PathFinderdescendents(=> sbt.PathdependencyPath, implicit sbt.Project.filter : (String)sbt.NameFilter"*.jar")
	/** The classpath containing all unmanaged classpath elements for the given configuration. This typically includes
	* at least 'unmanagedClasspath'.*/
	def (sbt.Configuration)sbt.PathFinderfullUnmanagedClasspath(sbt.Configurationconfig: sbt.ConfigurationConfiguration): sbt.PathFinderPathFinder
}

/** A project that provides automatic dependency management.*/
trait trait ManagedProject extends java.lang.Object with sbt.ClasspathProject with ScalaObjectManagedProject extends sbt.ClasspathProjectClasspathProject
{
	trait trait ManagedOption extends java.lang.Object with ManagedProject.this.ActionOptionManagedOption extends ManagedProject.this.ActionOptionActionOption
	final class class ManagedFlagOption extends java.lang.Object with ManagedProject.this.ManagedOption with ScalaObjectManagedFlagOption extends ManagedProject.this.ManagedOptionManagedOption
	/** An update option that specifies that unneeded files should be pruned from the managed library directory
	* after updating. */
	final val ManagedProject.this.ManagedFlagOptionSynchronize = ManagedProject.this.ManagedFlagOptionnew ManagedProject.this.ManagedFlagOptionManagedFlagOption
	/** An update option that specifies that Ivy should validate configurations.*/
	final val ManagedProject.this.ManagedFlagOptionValidate = ManagedProject.this.ManagedFlagOptionnew ManagedProject.this.ManagedFlagOptionManagedFlagOption
	/** An update option that puts Ivy into a quieter logging mode.*/
	final val ManagedProject.this.ManagedFlagOptionQuietUpdate = ManagedProject.this.ManagedFlagOptionnew ManagedProject.this.ManagedFlagOptionManagedFlagOption
	/** An update option that adds the scala-tools.org releases repository to the set of resolvers, unless
	* no inline repositories are present and an ivysettings.xml file is present.*/
	final val ManagedProject.this.ManagedFlagOptionAddScalaToolsReleases = ManagedProject.this.ManagedFlagOptionnew ManagedProject.this.ManagedFlagOptionManagedFlagOption
	/** An update option that specifies that an error should be generated if no inline dependencies, resolvers,
	* XML file, or Ivy or Maven configuration files are present.*/
	final val ManagedProject.this.ManagedFlagOptionErrorIfNoConfiguration = ManagedProject.this.ManagedFlagOptionnew ManagedProject.this.ManagedFlagOptionManagedFlagOption
	/** An update option that explicitly specifies the dependency manager to use.  This can be used to
	* override the default precendence. */
	final case class class LibraryManager extends java.lang.Object with ManagedProject.this.ManagedOption with ScalaObject with ProductLibraryManager(sbt.Managerm: sbt.ManagerManager) extends ManagedProject.this.ManagedOptionManagedOption
	/** An update option that overrides the default Ivy cache location. */
	final case class class CacheDirectory extends java.lang.Object with ManagedProject.this.ManagedOption with ScalaObject with ProductCacheDirectory(sbt.Pathdir: sbt.PathPath) extends ManagedProject.this.ManagedOptionManagedOption
	final case class class CheckScalaVersion extends java.lang.Object with ManagedProject.this.ManagedOption with ScalaObject with ProductCheckScalaVersion(Iterable[sbt.Configuration]configs: Iterable[sbt.Configuration]Iterable[Configuration], BooleancheckExplicit: BooleanBoolean, BooleanfilterImplicit: BooleanBoolean) extends ManagedProject.this.ManagedOptionManagedOption
	
	private def (String,sbt.Path,Seq[ManagedProject.this.ManagedOption])((sbt.IvyConfiguration, sbt.UpdateConfiguration) => Option[String])Option[String]withConfigurations(StringoutputPattern: StringString, sbt.PathmanagedDependencyPath: sbt.PathPath, Seq[ManagedProject.this.ManagedOption]options: Seq[ManagedProject.this.ManagedOption]Seq[ManagedOption])
		((sbt.IvyConfiguration, sbt.UpdateConfiguration) => Option[String]doWith: (IvyConfiguration, UpdateConfiguration) => Option[String]) =
	{
		var Booleansynchronize = Boolean(false)false
		var Booleanvalidate = Boolean(false)false
		var Booleanquiet = Boolean(false)false
		var BooleanaddScalaTools = Boolean(false)false
		var BooleanerrorIfNoConfiguration = Boolean(false)false
		var sbt.Managermanager: sbt.ManagerManager = sbt.AutoDetectManagernew sbt.AutoDetectManagerAutoDetectManager(=> sbt.ModuleIDprojectID)
		var Option[sbt.Path]cacheDirectory: Option[sbt.Path]Option[Path] = object NoneNone
		var Option[sbt.IvyScala]checkScalaVersion: Option[sbt.IvyScala]Option[IvyScala] = object NoneNone
		for(((ManagedProject.this.ManagedOption) => Unit)Unitoption <- Seq[ManagedProject.this.ManagedOption]options)
		{
			ManagedProject.this.ManagedOptionoption Unitmatch
			{
				Unitcase => ManagedProject.this.ManagedFlagOptionSynchronize => Booleansynchronize = Boolean(true)true
				Unitcase => ManagedProject.this.ManagedFlagOptionValidate => Booleanvalidate = Boolean(true)true
				Unitcase LibraryManager(sbt.Managerm) => sbt.Managermanager = sbt.Managerm
				Unitcase => ManagedProject.this.ManagedFlagOptionQuietUpdate => Booleanquiet = Boolean(true)true
				Unitcase => ManagedProject.this.ManagedFlagOptionAddScalaToolsReleases => BooleanaddScalaTools = Boolean(true)true
				Unitcase => ManagedProject.this.ManagedFlagOptionErrorIfNoConfiguration => BooleanerrorIfNoConfiguration = Boolean(true)true
				Unitcase CacheDirectory(sbt.Pathdir) => Option[sbt.Path]cacheDirectory = (sbt.Path)Some[sbt.Path]Some(sbt.Pathdir)
				Unitcase CheckScalaVersion(Iterable[sbt.Configuration]configs, BooleancheckExplicit, BooleanfilterImplicit) =>
					Option[sbt.IvyScala]checkScalaVersion = => Option[String]getScalaVersion.((String) => sbt.IvyScala)Option[sbt.IvyScala]map(Stringversion => sbt.IvyScalanew sbt.IvyScalaIvyScala(Stringversion, Iterable[sbt.Configuration]configs, BooleancheckExplicit, BooleanfilterImplicit))
				Unitcase _ => => sbt.Loggerlog.(=> String)Unitwarn(java.lang.String("Ignored unknown managed option ")"Ignored unknown managed option " (Any)java.lang.String+ ManagedProject.this.ManagedOptionoption)
			}
		}
		val sbt.IvyPathsivyPaths = sbt.IvyPathsnew sbt.IvyPathsIvyPaths(=> sbt.ProjectInfoinfo.=> sbt.ProjectDirectoryprojectPath, sbt.PathmanagedDependencyPath, Option[sbt.Path]cacheDirectory)
		val sbt.IvyFlagsivyFlags = sbt.IvyFlagsnew sbt.IvyFlagsIvyFlags(Booleanvalidate, BooleanaddScalaTools, BooleanerrorIfNoConfiguration)
		val sbt.IvyConfigurationivyConfiguration = sbt.IvyConfigurationnew sbt.IvyConfigurationIvyConfiguration(sbt.IvyPathsivyPaths, sbt.Managermanager, sbt.IvyFlagsivyFlags, Option[sbt.IvyScala]checkScalaVersion, => sbt.Loggerlog)
		val sbt.UpdateConfigurationupdateConfiguration = sbt.UpdateConfigurationnew sbt.UpdateConfigurationUpdateConfiguration(StringoutputPattern, Booleansynchronize, Booleanquiet)
		(sbt.IvyConfiguration,sbt.UpdateConfiguration)Option[String]doWith(sbt.IvyConfigurationivyConfiguration, sbt.UpdateConfigurationupdateConfiguration)
	}
	private def => Option[String]getScalaVersion =
	{
		val Stringv = => ManagedProject.this.Property[String]scalaVersion.=> Stringvalue
		Option[String]if(implicit scala.Predef.stringWrapper : (String)scala.runtime.RichStringv.=> BooleanisEmpty) object NoneNone
		else (String)Some[String]Some(Stringv)
	}
	private def (=> Option[String])ManagedProject.this.TaskwithIvyTask(=> Option[String]doTask: => Option[String]) =
		(=> Option[String])ManagedProject.this.Tasktask
		{
			try { => Option[String]doTask }
			catch
			{
				Some[java.lang.String]case java.lang.NoClassDefFoundErrore: java.lang.NoClassDefFoundErrorNoClassDefFoundError =>
					=> sbt.Loggerlog.(=> Throwable)Unittrace(java.lang.NoClassDefFoundErrore)
					(java.lang.String)Some[java.lang.String]Some(java.lang.String("Apache Ivy is required for dependency management (")"Apache Ivy is required for dependency management (" (Any)java.lang.String+ java.lang.NoClassDefFoundErrore.()java.lang.StringtoString (Any)java.lang.String+ java.lang.String(")")")")
			}
		}
	def (String,sbt.Path,ManagedProject.this.ManagedOption*)ManagedProject.this.TaskupdateTask(StringoutputPattern: StringString, sbt.PathmanagedDependencyPath: sbt.PathPath, ManagedProject.this.ManagedOption*options: ManagedProject.this.ManagedOption*ManagedOption*): ManagedProject.this.TaskTask =
		(String,sbt.Path,=> Seq[ManagedProject.this.ManagedOption])ManagedProject.this.TaskupdateTask(StringoutputPattern, sbt.PathmanagedDependencyPath, ManagedProject.this.ManagedOption*options)
	def (String,sbt.Path,=> Seq[ManagedProject.this.ManagedOption])ManagedProject.this.TaskupdateTask(StringoutputPattern: StringString, sbt.PathmanagedDependencyPath: sbt.PathPath, => Seq[ManagedProject.this.ManagedOption]options: => Seq[ManagedOption]) =
		(=> Option[String])ManagedProject.this.TaskwithIvyTask((String,sbt.Path,Seq[ManagedProject.this.ManagedOption])((sbt.IvyConfiguration, sbt.UpdateConfiguration) => Option[String])Option[String]withConfigurations(StringoutputPattern, sbt.PathmanagedDependencyPath, => Seq[ManagedProject.this.ManagedOption]options)(object sbt.ManageDependenciesManageDependencies.(sbt.IvyConfiguration,sbt.UpdateConfiguration)Option[String]update))
		
	def (sbt.PublishConfiguration,=> Seq[ManagedProject.this.ManagedOption])ManagedProject.this.TaskpublishTask(sbt.PublishConfigurationpublishConfig: sbt.PublishConfigurationPublishConfiguration, => Seq[ManagedProject.this.ManagedOption]options: => Seq[ManagedOption]) =
	{
		import publishConfig._
		(=> Option[String])ManagedProject.this.TaskwithIvyTask((String,sbt.Path,Seq[ManagedProject.this.ManagedOption])((sbt.IvyConfiguration, sbt.UpdateConfiguration) => Option[String])Option[String]withConfigurations(java.lang.String("")"", => sbt.PathmanagedDependencyPath, => Seq[ManagedProject.this.ManagedOption]options) { (sbt.IvyConfigurationivyConf, sbt.UpdateConfigurationignore) =>
			object sbt.ManageDependenciesManageDependencies.(sbt.IvyConfiguration,String,Iterable[String],String,Option[Iterable[sbt.Configuration]])Option[String]publish(sbt.IvyConfigurationivyConf, => StringresolverName, => Iterable[String]srcArtifactPatterns, => StringdeliveredPattern, => Option[Iterable[sbt.Configuration]]configurations) } )
	}
	def (sbt.PublishConfiguration,=> Seq[ManagedProject.this.ManagedOption])ManagedProject.this.TaskdeliverTask(sbt.PublishConfigurationdeliverConfig: sbt.PublishConfigurationPublishConfiguration, => Seq[ManagedProject.this.ManagedOption]options: => Seq[ManagedOption]) =
	{
		import deliverConfig._
		(=> Option[String])ManagedProject.this.TaskwithIvyTask((String,sbt.Path,Seq[ManagedProject.this.ManagedOption])((sbt.IvyConfiguration, sbt.UpdateConfiguration) => Option[String])Option[String]withConfigurations(java.lang.String("")"", => sbt.PathmanagedDependencyPath, => Seq[ManagedProject.this.ManagedOption]options) { (sbt.IvyConfigurationivyConf, sbt.UpdateConfigurationupdateConf) =>
			object sbt.ManageDependenciesManageDependencies.(sbt.IvyConfiguration,sbt.UpdateConfiguration,String,String,Iterable[sbt.ModuleID],Option[Iterable[sbt.Configuration]])Option[String]deliver(sbt.IvyConfigurationivyConf, sbt.UpdateConfigurationupdateConf, => Stringstatus, => StringdeliveredPattern, => Iterable[sbt.ModuleID]extraDependencies, => Option[Iterable[sbt.Configuration]]configurations) } )
	}
	def (sbt.Path,Iterable[sbt.ModuleID],=> Seq[ManagedProject.this.ManagedOption])ManagedProject.this.TaskmakePomTask(sbt.Pathoutput: sbt.PathPath, Iterable[sbt.ModuleID]extraDependencies: Iterable[sbt.ModuleID]Iterable[ModuleID], => Seq[ManagedProject.this.ManagedOption]options: => Seq[ManagedOption]) =
		(=> Option[String])ManagedProject.this.TaskwithIvyTask((String,sbt.Path,Seq[ManagedProject.this.ManagedOption])((sbt.IvyConfiguration, sbt.UpdateConfiguration) => Option[String])Option[String]withConfigurations(java.lang.String("")"", => sbt.PathmanagedDependencyPath: sbt.PathPath, => Seq[ManagedProject.this.ManagedOption]options) { (sbt.IvyConfigurationivyConf, sbt.UpdateConfigurationignore) =>
			object sbt.ManageDependenciesManageDependencies.(sbt.IvyConfiguration,Iterable[sbt.ModuleID],java.io.File)Option[String]makePom(sbt.IvyConfigurationivyConf, Iterable[sbt.ModuleID]extraDependencies, sbt.Pathoutput.=> java.io.FileasFile) })
		
	def (sbt.Path,=> Seq[ManagedProject.this.ManagedOption])ManagedProject.this.TaskcleanCacheTask(sbt.PathmanagedDependencyPath: sbt.PathPath, => Seq[ManagedProject.this.ManagedOption]options: => Seq[ManagedOption]) =
		(=> Option[String])ManagedProject.this.TaskwithIvyTask((String,sbt.Path,Seq[ManagedProject.this.ManagedOption])((sbt.IvyConfiguration, sbt.UpdateConfiguration) => Option[String])Option[String]withConfigurations(java.lang.String("")"", sbt.PathmanagedDependencyPath, => Seq[ManagedProject.this.ManagedOption]options) { (sbt.IvyConfigurationivyConf, sbt.UpdateConfigurationignore) => object sbt.ManageDependenciesManageDependencies.(sbt.IvyConfiguration)Option[String]cleanCache(sbt.IvyConfigurationivyConf) })
		
	def (sbt.Path)ManagedProject.this.TaskcleanLibTask(sbt.PathmanagedDependencyPath: sbt.PathPath) = (=> Option[String])ManagedProject.this.Tasktask { object sbt.FileUtilitiesFileUtilities.(Iterable[sbt.Path],sbt.Logger)Option[String]clean(sbt.PathmanagedDependencyPath.=> scala.collection.Set[sbt.Path]get, => sbt.Loggerlog) }
	
	def => sbt.ModuleIDprojectID: sbt.ModuleIDModuleID = (String,String,String,Option[String])sbt.ModuleIDModuleID(=> Stringorganization, => java.lang.StringnormalizedName, => sbt.Versionversion.()java.lang.StringtoString, object NoneNone)
	def => sbt.PathmanagedDependencyPath: sbt.PathPath
	/** The managed classpath for the given configuration, using the default configuration if this configuration
	* does not exist in the managed library directory.*/
	final def (sbt.Configuration)sbt.PathFindermanagedClasspath(sbt.Configurationconfig: sbt.ConfigurationConfiguration): sbt.PathFinderPathFinder = (sbt.Configuration,Boolean)sbt.PathFindermanagedClasspath(sbt.Configurationconfig, Boolean(true)true)
	/** The managed classpath for the given configuration.  If 'useDefaultFallback' is true, the default configuration
	* will be used if the configuration does not exist in the managed library directory.*/
	def (sbt.Configuration,Boolean)sbt.PathFindermanagedClasspath(sbt.Configurationconfig: sbt.ConfigurationConfiguration, BooleanuseDefaultFallback: BooleanBoolean): sbt.PathFinderPathFinder =
	{
		val sbt.PathconfigDirectory = => sbt.PathmanagedDependencyPath (String)sbt.Path/ sbt.Configurationconfig.()StringtoString
		val sbt.PathFinderuseDirectory =
			sbt.PathFinderif(sbt.PathconfigDirectory.=> java.io.FileasFile.()Booleanexists)
				sbt.PathconfigDirectory
			else sbt.PathFinderif(BooleanuseDefaultFallback)
				=> sbt.PathmanagedDependencyPath (String)sbt.Path/ object sbt.ConfigurationsConfigurations.=> sbt.ConfigurationDefault.()StringtoString
			else
				object sbt.PathPath.=> sbt.PathFinderemptyPathFinder
		(sbt.PathFinder,sbt.FileFilter)sbt.PathFinderdescendents(sbt.PathFinderuseDirectory, implicit sbt.Project.filter : (String)sbt.NameFilter"*.jar")
	}
	
	import StringUtilities.nonEmpty
	implicit def implicit sbt.ManagedProject.toGroupID : (String)sbt.GroupIDtoGroupID(StringgroupID: StringString): sbt.GroupIDGroupID =
	{
		(String,String)UnitnonEmpty(StringgroupID, java.lang.String("Group ID")"Group ID")
		sbt.GroupIDnew sbt.GroupIDGroupID(StringgroupID)
	}
	implicit def implicit sbt.ManagedProject.toRepositoryName : (String)sbt.RepositoryNametoRepositoryName(Stringname: StringString): sbt.RepositoryNameRepositoryName =
	{
		(String,String)UnitnonEmpty(Stringname, java.lang.String("Repository name")"Repository name")
		sbt.RepositoryNamenew sbt.RepositoryNameRepositoryName(Stringname)
	}
	implicit def implicit sbt.ManagedProject.moduleIDConfigurable : (sbt.ModuleID)sbt.ModuleIDConfigurablemoduleIDConfigurable(sbt.ModuleIDm: sbt.ModuleIDModuleID): sbt.ModuleIDConfigurableModuleIDConfigurable =
	{
		(Boolean,=> Any)Unitrequire(sbt.ModuleIDm.=> Option[String]configurations.=> BooleanisEmpty, java.lang.String("Configurations already specified for module ")"Configurations already specified for module " (Any)java.lang.String+ sbt.ModuleIDm)
		sbt.ModuleIDConfigurablenew sbt.ModuleIDConfigurableModuleIDConfigurable(sbt.ModuleIDm)
	}
	
	def (String)sbt.Configurationconfig(Stringname: StringString) = (String)sbt.Configurationnew sbt.ConfigurationConfiguration(Stringname)
}
/** This class groups required configuration for the deliver and publish tasks. */
trait trait PublishConfiguration extends java.lang.Object with NotNullPublishConfiguration extends NotNullNotNull
{
	/** The name of the resolver to which publishing should be done.*/
	def => StringresolverName: StringString
	/** The Ivy pattern used to determine the delivered Ivy file location.  An example is
	* (outputPath / "[artifact]-[revision].[ext]").relativePath */
	def => StringdeliveredPattern: StringString
	/** Ivy patterns used to find artifacts for publishing.  An example pattern is
	* (outputPath / "[artifact]-[revision].[ext]").relativePath */
	def => Iterable[String]srcArtifactPatterns: Iterable[String]Iterable[String]
	/** Additional dependencies to include for delivering/publishing only.  These are typically dependencies on
	* subprojects. */
	def => Iterable[sbt.ModuleID]extraDependencies: Iterable[sbt.ModuleID]Iterable[ModuleID]
	/** The status to use when delivering or publishing.  This might be "release" or "integration" or another valid Ivy status. */
	def => Stringstatus: StringString
	/**  The configurations to include in the publish/deliver action: specify none for all configurations. */
	def => Option[Iterable[sbt.Configuration]]configurations: Option[Iterable[sbt.Configuration]]Option[Iterable[Configuration]]
}
	
trait trait BasicManagedProject extends java.lang.Object with sbt.ManagedProject with sbt.ReflectiveManagedProject with sbt.BasicDependencyPaths with ScalaObjectBasicManagedProject extends sbt.ManagedProjectManagedProject with sbt.ReflectiveManagedProjectReflectiveManagedProject with sbt.BasicDependencyPathsBasicDependencyPaths
{
	import BasicManagedProject._
	/** The dependency manager that represents inline declarations.  The default manager packages the information
	* from 'ivyXML', 'projectID', 'repositories', and 'libraryDependencies' and does not typically need to be
	* be overridden. */
	def => sbt.SimpleManagermanager = sbt.SimpleManagernew sbt.SimpleManagerSimpleManager(=> scala.xml.NodeSeqivyXML, Boolean(true)true, => sbt.ModuleIDprojectID, => Set[sbt.Resolver]repositories, => Iterable[sbt.Configuration]ivyConfigurations, => Option[sbt.Configuration]defaultConfiguration, => Set[sbt.ModuleID]libraryDependencies.=> List[sbt.ModuleID]toList: _*)
	
	/** The pattern for Ivy to use when retrieving dependencies into the local project.  Classpath management
	* depends on the first directory being [conf] and the extension being [ext].*/
	def => java.lang.StringoutputPattern = java.lang.String("[conf]/[artifact](-[revision]).[ext]")"[conf]/[artifact](-[revision]).[ext]"
	/** Override this to specify the publications, configurations, and/or dependencies sections of an Ivy file.
	* See http://code.google.com/p/simple-build-tool/wiki/LibraryManagement for details.*/
	def => scala.xml.NodeSeqivyXML: scala.xml.scala.xml.NodeSeqNodeSeq = scala.xml.object scala.xml.NodeSeqNodeSeq.=> <refinement> extends scala.xml.NodeSeqEmpty
	/** The base options passed to the 'update' action. */
	def => List[BasicManagedProject.this.ManagedOption with ScalaObject]baseUpdateOptions = => BasicManagedProject.this.CheckScalaVersioncheckScalaVersion (BasicManagedProject.this.ManagedOption with ScalaObject)List[BasicManagedProject.this.ManagedOption with ScalaObject]:: => BasicManagedProject.this.ManagedFlagOptionValidate (BasicManagedProject.this.ManagedFlagOption)List[BasicManagedProject.this.ManagedFlagOption]:: => BasicManagedProject.this.ManagedFlagOptionSynchronize (BasicManagedProject.this.ManagedFlagOption)List[BasicManagedProject.this.ManagedFlagOption]:: => BasicManagedProject.this.ManagedFlagOptionQuietUpdate (BasicManagedProject.this.ManagedFlagOption)List[BasicManagedProject.this.ManagedFlagOption]:: => BasicManagedProject.this.ManagedFlagOptionAddScalaToolsReleases (BasicManagedProject.this.ManagedFlagOption)List[BasicManagedProject.this.ManagedFlagOption]:: object NilNil
	override def => Iterable[sbt.Configuration]ivyConfigurations: Iterable[sbt.Configuration]Iterable[Configuration] =
	{
		val Set[sbt.Configuration]reflective = => Set[sbt.Configuration]reflectiveIvyConfigurations
		Iterable[sbt.Configuration]if(=> BooleanuseMavenConfigurations)
		{
			val List[sbt.Configuration]base = object sbt.ConfigurationsConfigurations.=> List[sbt.Configuration]defaultMavenConfigurations (Iterable[sbt.Configuration])List[sbt.Configuration]++ Set[sbt.Configuration]reflective
			val List[sbt.Configuration]allConfigurations =
				List[sbt.Configuration]if(=> BooleanuseIntegrationTestConfiguration)
					List[sbt.Configuration]base (Iterable[sbt.Configuration])List[sbt.Configuration]++ (sbt.Configuration*)List[sbt.Configuration]List(object sbt.ConfigurationsConfigurations.=> sbt.ConfigurationIntegrationTest)
				else
					List[sbt.Configuration]base
			object sbt.ConfigurationsConfigurations.(Iterable[sbt.Configuration])scala.collection.immutable.Set[sbt.Configuration]removeDuplicates(List[sbt.Configuration]allConfigurations)
		}
		else
			Set[sbt.Configuration]reflective
	}
	def => BooleanuseIntegrationTestConfiguration = Boolean(false)false
	def => Option[sbt.Configuration]defaultConfiguration = Option[sbt.Configuration]if(=> BooleanuseMavenConfigurations) (sbt.Configuration)Some[sbt.Configuration]Some(object sbt.ConfigurationsConfigurations.=> sbt.ConfigurationCompile) else object NoneNone
	def => BooleanuseMavenConfigurations = Boolean(false)false
	/** The options provided to the 'update' action.  This is by default the options in 'baseUpdateOptions'.
	* If 'manager' has any dependencies, resolvers, or inline Ivy XML (which by default happens when inline
	* dependency management is used), it is passed as the dependency manager.*/
	def => Seq[BasicManagedProject.this.ManagedOption]updateOptions: Seq[BasicManagedProject.this.ManagedOption]Seq[ManagedOption] =
	{
		val sbt.SimpleManagerm = => sbt.SimpleManagermanager
		Seq[BasicManagedProject.this.ManagedOption]if(sbt.SimpleManagerm.=> sbt.ModuleID*dependencies.=> BooleanisEmpty (Boolean)Boolean&& sbt.SimpleManagerm.=> Iterable[sbt.Resolver]resolvers.=> BooleanisEmpty (Boolean)Boolean&& => scala.xml.NodeSeqivyXML.=> BooleanisEmpty)
			=> List[BasicManagedProject.this.ManagedOption with ScalaObject]baseUpdateOptions
		else
			(sbt.Manager)BasicManagedProject.this.LibraryManagerLibraryManager(sbt.SimpleManagerm) (BasicManagedProject.this.ManagedOption with ScalaObject)List[BasicManagedProject.this.ManagedOption with ScalaObject]:: => List[BasicManagedProject.this.ManagedOption with ScalaObject]baseUpdateOptions
	}
	/** True if the 'provided' configuration should be included on the 'compile' classpath.  The default value is true.*/
	def => BooleanincludeProvidedWithCompile = Boolean(true)true
	/** True if the default implicit extensions should be used when determining classpaths.  The default value is true. */
	def => BooleandefaultConfigurationExtensions = Boolean(true)true
	/** If true, verify that explicit dependencies on Scala libraries use the same version as scala.version. */
	def => BooleancheckExplicitScalaDependencies = Boolean(true)true
	/** If true, filter dependencies on scala-library and scala-compiler. This is true by default to avoid conflicts with
	* the jars provided by sbt.  You can set this to false to download these jars.  Overriding checkScalaInConfigurations might
	* be more appropriate, however.*/
	def => BooleanfilterScalaJars = Boolean(true)true
	/** The configurations to check/filter.*/
	def => Iterable[sbt.Configuration]checkScalaInConfigurations: Iterable[sbt.Configuration]Iterable[Configuration] = => Iterable[sbt.Configuration]ivyConfigurations
	def => BasicManagedProject.this.CheckScalaVersioncheckScalaVersion = (Iterable[sbt.Configuration],Boolean,Boolean)BasicManagedProject.this.CheckScalaVersionCheckScalaVersion(=> Iterable[sbt.Configuration]checkScalaInConfigurations, => BooleancheckExplicitScalaDependencies, => BooleanfilterScalaJars)
	/** Includes the Provided configuration on the Compile classpath.  This can be overridden by setting
	* includeProvidedWithCompile to false.*/
	override def (sbt.Configuration,Boolean)sbt.PathFindermanagedClasspath(sbt.Configurationconfig: sbt.ConfigurationConfiguration, BooleanuseDefaultFallback: BooleanBoolean) =
	{
		import Configurations.{Compile, Provided, Runtime, Test}
		val sbt.PathFindersuperClasspath = (sbt.Configuration,Boolean)sbt.PathFindersuper.(sbt.Configuration,Boolean)sbt.PathFindermanagedClasspath(sbt.Configurationconfig, BooleanuseDefaultFallback)
		sbt.PathFinderif(sbt.Configurationconfig (AnyRef)Boolean== => sbt.ConfigurationCompile (Boolean)Boolean&& => BooleanincludeProvidedWithCompile)
			sbt.PathFindersuperClasspath (sbt.PathFinder)sbt.PathFinder+++ (sbt.Configuration,Boolean)sbt.PathFindersuper.managedClasspath(=> sbt.ConfigurationProvided, Boolean(false)false)
		else sbt.PathFinderif(=> BooleandefaultConfigurationExtensions (Boolean)Boolean&& sbt.Configurationconfig (AnyRef)Boolean== => sbt.ConfigurationRuntime)
			sbt.PathFindersuperClasspath (sbt.PathFinder)sbt.PathFinder+++ (sbt.Configuration,Boolean)sbt.PathFindersuper.managedClasspath(=> sbt.ConfigurationCompile, Boolean(false)false)
		else sbt.PathFinderif(=> BooleandefaultConfigurationExtensions (Boolean)Boolean&& sbt.Configurationconfig (AnyRef)Boolean== => sbt.ConfigurationTest)
			sbt.PathFindersuperClasspath (sbt.PathFinder)sbt.PathFinder+++ (sbt.Configuration,Boolean)sbt.PathFindersuper.managedClasspath(=> sbt.ConfigurationCompile, Boolean(false)false) (sbt.PathFinder)sbt.PathFinder+++ (sbt.Configuration,Boolean)sbt.PathFindersuper.managedClasspath(=> sbt.ConfigurationRuntime, Boolean(false)false)
		else
			sbt.PathFindersuperClasspath
	}
	
	protected def => BasicManagedProject.this.TaskupdateAction = (String,sbt.Path,=> Seq[BasicManagedProject.this.ManagedOption])BasicManagedProject.this.TaskupdateTask(=> java.lang.StringoutputPattern, => sbt.PathmanagedDependencyPath, => Seq[BasicManagedProject.this.ManagedOption]updateOptions) (String)BasicManagedProject.this.TaskdescribedAs => java.lang.StringUpdateDescription
	protected def => BasicManagedProject.this.TaskcleanLibAction = (sbt.Path)BasicManagedProject.this.TaskcleanLibTask(=> sbt.PathmanagedDependencyPath) (String)BasicManagedProject.this.TaskdescribedAs => java.lang.StringCleanLibDescription
	protected def => BasicManagedProject.this.TaskcleanCacheAction = (sbt.Path,=> Seq[BasicManagedProject.this.ManagedOption])BasicManagedProject.this.TaskcleanCacheTask(=> sbt.PathmanagedDependencyPath, => Seq[BasicManagedProject.this.ManagedOption]updateOptions) (String)BasicManagedProject.this.TaskdescribedAs => java.lang.StringCleanCacheDescription
	
	protected def => List[sbt.ModuleID]deliverProjectDependencies =
	{
		val scala.collection.mutable.ListBuffer[sbt.ModuleID]interDependencies = scala.collection.mutable.ListBuffer[sbt.ModuleID]new scala.collection.mutable.scala.collection.mutable.ListBuffer[sbt.ModuleID]ListBuffer[ModuleID]
		=> Iterable[sbt.Project]dependencies.((sbt.Project) => Unit)Unitforeach(sbt.Projectdep => sbt.Projectdep Unitmatch { Unitcase sbt.ManagedProjectmp: sbt.ManagedProjectManagedProject => scala.collection.mutable.ListBuffer[sbt.ModuleID]interDependencies (sbt.ModuleID)Unit+= sbt.ManagedProjectmp.=> sbt.ModuleIDprojectID; Unitcase _ => Unit() })
		scala.collection.mutable.ListBuffer[sbt.ModuleID]interDependencies.=> List[sbt.ModuleID]readOnly
	}
	protected def => BasicManagedProject.this.TaskmakePomAction = (sbt.Path,Iterable[sbt.ModuleID],=> Seq[BasicManagedProject.this.ManagedOption])BasicManagedProject.this.TaskmakePomTask(=> sbt.PathoutputPath (String)sbt.Path/ java.lang.String("pom.xml")"pom.xml", => List[sbt.ModuleID]deliverProjectDependencies, => Seq[BasicManagedProject.this.ManagedOption]updateOptions)
	protected def => BasicManagedProject.this.TaskdeliverLocalAction = (sbt.PublishConfiguration,=> Seq[BasicManagedProject.this.ManagedOption])BasicManagedProject.this.TaskdeliverTask(=> BasicManagedProject.this.DefaultPublishConfigurationpublishLocalConfiguration, => Seq[BasicManagedProject.this.ManagedOption]updateOptions)
	protected def => BasicManagedProject.this.TaskpublishLocalAction = (sbt.PublishConfiguration,=> Seq[BasicManagedProject.this.ManagedOption])BasicManagedProject.this.TaskpublishTask(=> BasicManagedProject.this.DefaultPublishConfigurationpublishLocalConfiguration, => Seq[BasicManagedProject.this.ManagedOption]updateOptions) (BasicManagedProject.this.ManagedTask*)BasicManagedProject.this.TaskdependsOn(=> BasicManagedProject.this.TaskdeliverLocal)
	protected def => BasicManagedProject.this.DefaultPublishConfigurationpublishLocalConfiguration = BasicManagedProject.this.DefaultPublishConfigurationnew BasicManagedProject.this.DefaultPublishConfigurationDefaultPublishConfiguration(java.lang.String("local")"local", java.lang.String("release")"release")
	protected class class DefaultPublishConfiguration extends java.lang.Object with sbt.PublishConfiguration with ScalaObjectDefaultPublishConfiguration(val StringresolverName: StringString, val Stringstatus: StringString) extends sbt.PublishConfigurationPublishConfiguration
	{
		protected def => sbt.PathdeliveredPathPattern = => sbt.PathoutputPath (String)sbt.Path/ java.lang.String("[artifact]-[revision].[ext]")"[artifact]-[revision].[ext]"
		def => StringdeliveredPattern = => sbt.PathdeliveredPathPattern.=> StringrelativePath
		def => Iterable[String]srcArtifactPatterns: Iterable[String]Iterable[String] =
		{
			val List[sbt.Path]pathPatterns =
				(=> sbt.PathoutputPath (String)sbt.Path/ java.lang.String("[artifact]-[revision]-[type].[ext]")"[artifact]-[revision]-[type].[ext]") (sbt.Path)List[sbt.Path]::
				(=> sbt.PathoutputPath (String)sbt.Path/ java.lang.String("[artifact]-[revision].[ext]")"[artifact]-[revision].[ext]") (sbt.Path)List[sbt.Path]::
				object NilNil
			List[sbt.Path]pathPatterns.((sbt.Path) => String)List[String]map(sbt.Path_.=> StringrelativePath)
		}
		def => Iterable[sbt.ModuleID]extraDependencies: Iterable[sbt.ModuleID]Iterable[ModuleID] = object NilNil//deliverProjectDependencies
		/**  The configurations to include in the publish/deliver action: specify none for all configurations. */
		def => Option[Iterable[sbt.Configuration]]configurations: Option[Iterable[sbt.Configuration]]Option[Iterable[Configuration]] = object NoneNone
	}
	
	lazy val BasicManagedProject.this.Taskupdate = => BasicManagedProject.this.TaskupdateAction
	lazy val BasicManagedProject.this.TaskmakePom = => BasicManagedProject.this.TaskmakePomAction
	lazy val BasicManagedProject.this.TaskdeliverLocal = => BasicManagedProject.this.TaskdeliverLocalAction
	lazy val BasicManagedProject.this.TaskpublishLocal = => BasicManagedProject.this.TaskpublishLocalAction
	lazy val BasicManagedProject.this.TaskcleanLib = => BasicManagedProject.this.TaskcleanLibAction
	lazy val BasicManagedProject.this.TaskcleanCache = => BasicManagedProject.this.TaskcleanCacheAction
}

object object sbt.BasicManagedProjectBasicManagedProject
{
	val java.lang.StringUpdateDescription =
		java.lang.String("Resolves and retrieves automatically managed dependencies.")"Resolves and retrieves automatically managed dependencies."
	val java.lang.StringCleanLibDescription =
		java.lang.String("Deletes the managed library directory.")"Deletes the managed library directory."
	val java.lang.StringCleanCacheDescription =
		java.lang.String("Deletes the cache of artifacts downloaded for automatically managed dependencies.")"Deletes the cache of artifacts downloaded for automatically managed dependencies."
}

trait trait BasicDependencyPaths extends java.lang.Object with sbt.Project with ScalaObjectBasicDependencyPaths extends sbt.ProjectProject
{
	import BasicDependencyPaths._
	def => java.lang.StringdependencyDirectoryName = => java.lang.StringDefaultDependencyDirectoryName
	def => java.lang.StringmanagedDirectoryName = => java.lang.StringDefaultManagedDirectoryName
	def => sbt.PathdependencyPath = implicit sbt.Project.path : (String)sbt.Pathpath(=> java.lang.StringdependencyDirectoryName)
	def => sbt.PathmanagedDependencyPath = implicit sbt.Project.path : (String)sbt.Pathpath(=> java.lang.StringmanagedDirectoryName)
}
object object sbt.BasicDependencyPathsBasicDependencyPaths
{
	val java.lang.StringDefaultManagedDirectoryName = java.lang.String("lib_managed")"lib_managed"
	val java.lang.StringDefaultDependencyDirectoryName = java.lang.String("lib")"lib"
}

object object sbt.StringUtilitiesStringUtilities
{
	def (String,String)UnitnonEmpty(Strings: StringString, Stringlabel: StringString)
	{
		(Boolean,=> Any)Unitrequire(Strings.()java.lang.Stringtrim.()Intlength (Int)Boolean> Int(0)0, Stringlabel (Any)java.lang.String+ java.lang.String(" cannot be empty.")" cannot be empty.")
	}
}
import StringUtilities.nonEmpty
final class class GroupID extends java.lang.Object with NotNull with ScalaObjectGroupID private[sbt] (StringgroupID: StringString) extends NotNullNotNull
{
	def (String)sbt.GroupArtifactID% (StringartifactID: StringString) =
	{
		(String,String)UnitnonEmpty(StringartifactID, java.lang.String("Artifact ID")"Artifact ID")
		sbt.GroupArtifactIDnew sbt.GroupArtifactIDGroupArtifactID(StringgroupID, StringartifactID)
	}
}
final class class GroupArtifactID extends java.lang.Object with NotNull with ScalaObjectGroupArtifactID private[sbt] (StringgroupID: StringString, StringartifactID: StringString) extends NotNullNotNull
{
	def (String)sbt.ModuleID% (Stringrevision: StringString): sbt.ModuleIDModuleID =
	{
		(String,String)UnitnonEmpty(Stringrevision, java.lang.String("Revision")"Revision")
		(String,String,String,Option[String])sbt.ModuleIDModuleID(StringgroupID, StringartifactID, Stringrevision, object NoneNone)
	}
}
final class class ModuleIDConfigurable extends java.lang.Object with NotNull with ScalaObjectModuleIDConfigurable private[sbt] (sbt.ModuleIDmoduleID: sbt.ModuleIDModuleID) extends NotNullNotNull
{
	def (String)sbt.ModuleID% (Stringconfigurations: StringString): sbt.ModuleIDModuleID =
	{
		(String,String)UnitnonEmpty(Stringconfigurations, java.lang.String("Configurations")"Configurations")
		import moduleID._
		(String,String,String,Option[String])sbt.ModuleIDModuleID(=> Stringorganization, => Stringname, => Stringrevision, (String)Some[String]Some(Stringconfigurations))
	}
}
final class class RepositoryName extends java.lang.Object with NotNull with ScalaObjectRepositoryName private[sbt] (Stringname: StringString) extends NotNullNotNull
{
	def (String)sbt.MavenRepositoryat (Stringlocation: StringString) =
	{
		(String,String)UnitnonEmpty(Stringlocation, java.lang.String("Repository location")"Repository location")
		sbt.MavenRepositorynew sbt.MavenRepositoryMavenRepository(Stringname, Stringlocation)
	}
}

import scala.collection.{Map, mutable}
/** A Project that determines its tasks by reflectively finding all vals with a type
* that conforms to Task.*/
trait trait ReflectiveTasks extends java.lang.Object with sbt.Project with ScalaObjectReflectiveTasks extends sbt.ProjectProject
{
	def => scala.collection.Map[String,ReflectiveTasks.this.Task]tasks: scala.collection.Map[String,ReflectiveTasks.this.Task]Map[String, Task] = => scala.collection.Map[String,ReflectiveTasks.this.Task]reflectiveTaskMappings
	def => scala.collection.Map[String,ReflectiveTasks.this.Task]reflectiveTaskMappings : scala.collection.Map[String,ReflectiveTasks.this.Task]Map[String, Task] = object sbt.ReflectiveReflective.(AnyRef)(implicit scala.reflect.Manifest[ReflectiveTasks.this.Task])scala.collection.Map[String,ReflectiveTasks.this.Task]reflectiveMappings[ReflectiveTasks.this.TaskTask](sbt.ReflectiveTasksthis)
}
/** A Project that determines its method tasks by reflectively finding all vals with a type
* that conforms to MethodTask.*/
trait trait ReflectiveMethods extends java.lang.Object with sbt.Project with ScalaObjectReflectiveMethods extends sbt.ProjectProject
{
	def => scala.collection.Map[String,ReflectiveMethods.this.MethodTask]methods: scala.collection.Map[String,ReflectiveMethods.this.MethodTask]Map[String, MethodTask] = => scala.collection.Map[String,ReflectiveMethods.this.MethodTask]reflectiveMethodMappings
	def => scala.collection.Map[String,ReflectiveMethods.this.MethodTask]reflectiveMethodMappings : scala.collection.Map[String,ReflectiveMethods.this.MethodTask]Map[String, MethodTask] = object sbt.ReflectiveReflective.(AnyRef)(implicit scala.reflect.Manifest[ReflectiveMethods.this.MethodTask])scala.collection.Map[String,ReflectiveMethods.this.MethodTask]reflectiveMappings[ReflectiveMethods.this.MethodTaskMethodTask](sbt.ReflectiveMethodsthis)
}
/** A Project that determines its dependencies on other projects by reflectively
* finding all vals with a type that conforms to Project.*/
trait trait ReflectiveModules extends java.lang.Object with sbt.Project with ScalaObjectReflectiveModules extends sbt.ProjectProject
{
	override def => scala.collection.Map[String,sbt.Project]subProjects: scala.collection.Map[String,sbt.Project]Map[String, Project] = => scala.collection.Map[String,sbt.Project]reflectiveModuleMappings
	def => scala.collection.Map[String,sbt.Project]reflectiveModuleMappings : scala.collection.Map[String,sbt.Project]Map[String, Project] = object sbt.ReflectiveReflective.(AnyRef)(implicit scala.reflect.Manifest[sbt.Project])scala.collection.Map[String,sbt.Project]reflectiveMappings[sbt.ProjectProject](sbt.ReflectiveModulesthis)
}
/** A Project that determines its dependencies on other projects by reflectively
* finding all vals with a type that conforms to Project and determines its tasks
* by reflectively finding all vals with a type that conforms to Task.*/
trait trait ReflectiveProject extends java.lang.Object with sbt.ReflectiveModules with sbt.ReflectiveTasks with sbt.ReflectiveMethodsReflectiveProject extends sbt.ReflectiveModulesReflectiveModules with sbt.ReflectiveTasksReflectiveTasks with sbt.ReflectiveMethodsReflectiveMethods

/** This Project subclass is used to contain other projects as dependencies.*/
class class ParentProject extends java.lang.Object with sbt.BasicDependencyProject with ScalaObjectParentProject(val sbt.ProjectInfoinfo: sbt.ProjectInfoProjectInfo) extends sbt.BasicDependencyProjectBasicDependencyProject
{
	def => Collection[sbt.Project]dependencies = => sbt.ProjectInfoinfo.=> Iterable[sbt.Project]dependencies (Iterable[sbt.Project])Collection[sbt.Project]++ => scala.collection.Map[String,sbt.Project]subProjects.=> Iterator[sbt.Project]values.=> List[sbt.Project]toList
	/** The directories to which a project writes are listed here and is used
	* to check a project and its dependencies for collisions.*/
	override def => List[sbt.Path]outputDirectories = => sbt.PathmanagedDependencyPath (sbt.Path)List[sbt.Path]:: => sbt.PathoutputPath (sbt.Path)List[sbt.Path]:: object NilNil
	def (sbt.Configuration)sbt.PathFinderfullUnmanagedClasspath(sbt.Configurationconfig: sbt.ConfigurationConfiguration) = => sbt.PathFinderunmanagedClasspath
}

object object sbt.ReflectiveReflective
{
	def [T](AnyRef)(implicit scala.reflect.Manifest[T])scala.collection.Map[String,T]reflectiveMappings[>: Nothing <: AnyT](AnyRefobj: AnyRefAnyRef)(implicit scala.reflect.Manifest[T]m: scala.reflect.scala.reflect.Manifest[T]Manifest[T]): scala.collection.Map[String,T]Map[String, T] =
	{
		val scala.collection.mutable.OpenHashMap[String,T]mappings = ()scala.collection.mutable.OpenHashMap[String,T]new mutable.scala.collection.mutable.OpenHashMap[String,T]OpenHashMap[String, T]
		for ((((String, T)) => Unit)Unit(Stringname, Tvalue) <- object sbt.ReflectUtilitiesReflectUtilities.(AnyRef)(implicit scala.reflect.Manifest[T])scala.collection.Map[String,T]allVals[TT](AnyRefobj))
			scala.collection.mutable.OpenHashMap[String,T]mappings(object sbt.ReflectUtilitiesReflectUtilities.(String,Char)StringtransformCamelCase(Stringname, Char('-')'-')) = Tvalue
		scala.collection.mutable.OpenHashMap[String,T]mappings
	}
}

/** A Project that determines its library dependencies by reflectively finding all vals with a type
* that conforms to ModuleID.*/
trait trait ReflectiveLibraryDependencies extends java.lang.Object with sbt.ManagedProject with ScalaObjectReflectiveLibraryDependencies extends sbt.ManagedProjectManagedProject
{
	def => Iterable[sbt.ModuleID]excludeIDs: Iterable[sbt.ModuleID]Iterable[ModuleID] = => sbt.ModuleIDprojectID (sbt.ModuleID)List[sbt.ModuleID]:: object NilNil
	def => Set[sbt.ModuleID]libraryDependencies: Set[sbt.ModuleID]Set[ModuleID] = => Set[sbt.ModuleID]reflectiveLibraryDependencies
	def => Set[sbt.ModuleID]reflectiveLibraryDependencies : Set[sbt.ModuleID]Set[ModuleID] = (sbt.ModuleID*)scala.collection.immutable.Set[sbt.ModuleID]Set(object sbt.ReflectiveReflective.(AnyRef)(implicit scala.reflect.Manifest[sbt.ModuleID])scala.collection.Map[String,sbt.ModuleID]reflectiveMappings[sbt.ModuleIDModuleID](sbt.ReflectiveLibraryDependenciesthis).=> Iterator[sbt.ModuleID]values.=> List[sbt.ModuleID]toList: _*) (Iterable[sbt.ModuleID])scala.collection.immutable.Set[sbt.ModuleID]-- => Iterable[sbt.ModuleID]excludeIDs
}

trait trait ReflectiveConfigurations extends java.lang.Object with sbt.Project with ScalaObjectReflectiveConfigurations extends sbt.ProjectProject
{
	def => Iterable[sbt.Configuration]ivyConfigurations: Iterable[sbt.Configuration]Iterable[Configuration] = => Set[sbt.Configuration]reflectiveIvyConfigurations
	def => Set[sbt.Configuration]reflectiveIvyConfigurations: Set[sbt.Configuration]Set[Configuration] = object sbt.ConfigurationsConfigurations.(Iterable[sbt.Configuration])scala.collection.immutable.Set[sbt.Configuration]removeDuplicates(object sbt.ReflectiveReflective.(AnyRef)(implicit scala.reflect.Manifest[sbt.Configuration])scala.collection.Map[String,sbt.Configuration]reflectiveMappings[sbt.ConfigurationConfiguration](sbt.ReflectiveConfigurationsthis).=> Iterator[sbt.Configuration]values.=> List[sbt.Configuration]toList)
}

/** A Project that determines its library dependencies by reflectively finding all vals with a type
* that conforms to ModuleID.*/
trait trait ReflectiveRepositories extends java.lang.Object with sbt.Project with ScalaObjectReflectiveRepositories extends sbt.ProjectProject
{
	def => Set[sbt.Resolver]repositories: Set[sbt.Resolver]Set[Resolver] = => Set[sbt.Resolver]reflectiveRepositories
	def => Set[sbt.Resolver]reflectiveRepositories: Set[sbt.Resolver]Set[Resolver] = (sbt.Resolver*)scala.collection.immutable.Set[sbt.Resolver]Set(object sbt.ReflectiveReflective.(AnyRef)(implicit scala.reflect.Manifest[sbt.Resolver])scala.collection.Map[String,sbt.Resolver]reflectiveMappings[sbt.ResolverResolver](sbt.ReflectiveRepositoriesthis).=> Iterator[sbt.Resolver]values.=> List[sbt.Resolver]toList: _*)
}

trait trait ReflectiveManagedProject extends java.lang.Object with sbt.ReflectiveProject with sbt.ReflectiveRepositories with sbt.ReflectiveLibraryDependencies with sbt.ReflectiveConfigurationsReflectiveManagedProject extends sbt.ReflectiveProjectReflectiveProject with sbt.ReflectiveRepositoriesReflectiveRepositories with sbt.ReflectiveLibraryDependenciesReflectiveLibraryDependencies with sbt.ReflectiveConfigurationsReflectiveConfigurations