Load

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def activateGlobalPlugin(config: sbt.LoadBuildConfiguration): sbt.LoadBuildConfiguration

def addOverrides(unit: sbt.BuildUnit, loaders: BuildLoader): BuildLoader

def addResolvers(unit: sbt.BuildUnit, isRoot: Boolean, loaders: BuildLoader): BuildLoader

def apply(rootBase: File, s: State, config: sbt.LoadBuildConfiguration): (() ⇒ Eval, sbt.BuildStructure)

final def asInstanceOf[T0]: T0

val autoPluginSettings: Seq[Def.Setting[_]]

These are the settings defined when loading a project "meta" build.

def buildConfigurations(loaded: sbt.LoadedBuild, rootProject: (URI) ⇒ String, injectSettings: InjectSettings): Seq[Def.Setting[_]]

def buildGlobalSettings(base: File, files: Seq[File], config: sbt.LoadBuildConfiguration): (ClassLoader) ⇒ Seq[Def.Setting[_]]

def buildPluginDefinition(dir: File, s: State, config: sbt.LoadBuildConfiguration): PluginData

def buildPlugins(dir: File, s: State, config: sbt.LoadBuildConfiguration): sbt.LoadedPlugins

def buildSettings(unit: sbt.BuildUnit): Seq[Def.Setting[_]]

def builtinLoader(s: State, config: sbt.LoadBuildConfiguration): BuildLoader

def checkAll(referenced: Map[URI, List[ProjectReference]], builds: Map[URI, sbt.PartBuildUnit]): Unit

def checkBuildBase(base: File): Unit

def checkDirectory(base: File): Unit

def checkProjectBase(buildBase: File, projectBase: File): Unit

def cleanEvalClasses(base: File, keep: Seq[File]): Unit

This will clean up left-over files in the config-classes directory if they are no longer used.

def clone(): AnyRef

def configInherit(lb: sbt.LoadedBuild, ref: ResolvedReference, config: ConfigKey, rootProject: (URI) ⇒ String): Seq[ConfigKey]

def configInheritRef(lb: sbt.LoadedBuild, ref: ProjectRef, config: ConfigKey): Seq[ConfigKey]

def configurationOpt(map: Map[URI, sbt.LoadedBuildUnit], uri: URI, id: String, conf: ConfigKey): Option[Configuration]

def defaultDelegates: (sbt.LoadedBuild) ⇒ (Scope) ⇒ Seq[Scope]

def defaultEvalOptions: Seq[String]

def defaultLoad(state: State, baseDirectory: File, log: Logger, isPlugin: Boolean = false, topLevelExtras: List[URI] = Nil): (() ⇒ Eval, sbt.BuildStructure)

def defaultPreGlobal(state: State, baseDirectory: File, definesClass: (File) ⇒ (String) ⇒ Boolean, globalBase: File, log: Logger): sbt.LoadBuildConfiguration

def defaultWithGlobal(state: State, base: File, rawConfig: sbt.LoadBuildConfiguration, globalBase: File, log: Logger): sbt.LoadBuildConfiguration

def emptyBuild(uri: URI): Nothing

def enableSbtPlugin(config: sbt.LoadBuildConfiguration): sbt.LoadBuildConfiguration

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalTransforms(ss: Seq[Def.Setting[_]]): Seq[Def.Setting[_]]

def finalize(): Unit

def getBuild[T](map: Map[URI, T], uri: URI): T

final def getClass(): Class[_]

def getConfiguration(map: Map[URI, sbt.LoadedBuildUnit], uri: URI, id: String, conf: ConfigKey): Configuration

def getProject(map: Map[URI, sbt.LoadedBuildUnit], uri: URI, id: String): ResolvedProject

def getRootProject(map: Map[URI, sbt.BuildUnitBase]): (URI) ⇒ String

def globalPluginClasspath(globalPlugin: Option[GlobalPlugin]): Seq[Attributed[File]]

def hasDefinition(dir: File): Boolean

def hashCode(): Int

def initialSession(structure: sbt.BuildStructure, rootEval: () ⇒ Eval): SessionSettings

def initialSession(structure: sbt.BuildStructure, rootEval: () ⇒ Eval, s: State): SessionSettings

def injectGlobal(state: State): Seq[Def.Setting[_]]

final def isInstanceOf[T0]: Boolean

def isProjectThis(s: Def.Setting[_]): Boolean

def lazyEval(unit: sbt.BuildUnit): () ⇒ Eval

def load(file: File, loaders: BuildLoader, extra: List[URI]): sbt.PartBuild

def load(file: File, s: State, config: sbt.LoadBuildConfiguration): sbt.PartBuild

def loadAll(bases: List[URI], references: Map[URI, List[ProjectReference]], loaders: BuildLoader, builds: Map[URI, sbt.PartBuildUnit]): (Map[URI, List[ProjectReference]], Map[URI, sbt.PartBuildUnit], BuildLoader)

def loadGlobal(state: State, base: File, global: File, config: sbt.LoadBuildConfiguration): sbt.LoadBuildConfiguration

def loadGlobalSettings(base: File, globalBase: File, files: Seq[File], config: sbt.LoadBuildConfiguration): sbt.LoadBuildConfiguration

def loadPluginDefinition(dir: File, config: sbt.LoadBuildConfiguration, pluginData: PluginData): sbt.LoadedPlugins

def loadPlugins(dir: File, data: PluginData, loader: ClassLoader): sbt.LoadedPlugins

def loadURI(uri: URI, loaders: BuildLoader, extra: List[URI]): sbt.PartBuild

def loadUnit(uri: URI, localBase: File, s: State, config: sbt.LoadBuildConfiguration): sbt.BuildUnit

def loaded(unit: sbt.BuildUnit): (sbt.PartBuildUnit, List[ProjectReference])

def mkEval(classpath: Seq[File], base: File, options: Seq[String]): Eval

def mkEval(defs: sbt.LoadedDefinitions, plugs: sbt.LoadedPlugins, options: Seq[String]): Eval

def mkEval(unit: sbt.BuildUnit): Eval

final def ne(arg0: AnyRef): Boolean

def noBuild(uri: URI): Nothing

def noConfiguration(uri: URI, id: String, conf: String): Nothing

def noPlugins(dir: File, config: sbt.LoadBuildConfiguration): sbt.LoadedPlugins

def noProject(uri: URI, id: String): Nothing

final def notify(): Unit

final def notifyAll(): Unit

def pluginDefinitionLoader(config: sbt.LoadBuildConfiguration, depcp: Seq[Attributed[File]], defcp: Seq[Attributed[File]]): (Seq[Attributed[File]], ClassLoader)

def pluginDefinitionLoader(config: sbt.LoadBuildConfiguration, pluginData: PluginData): (Seq[Attributed[File]], ClassLoader)

def pluginDefinitionLoader(config: sbt.LoadBuildConfiguration, dependencyClasspath: Seq[Attributed[File]]): (Seq[Attributed[File]], ClassLoader)

def plugins(dir: File, s: State, config: sbt.LoadBuildConfiguration): sbt.LoadedPlugins

def projectInherit(lb: sbt.LoadedBuild, ref: ProjectRef): Seq[ProjectRef]

def projectMap(structure: sbt.BuildStructure, current: Map[URI, String]): Map[URI, String]

def projectScope(project: Reference): Scope

def projects(unit: sbt.BuildUnit): Seq[Project]

def reapply(newSettings: Seq[Def.Setting[_]], structure: sbt.BuildStructure)(implicit display: Show[Def.ScopedKey[_]]): sbt.BuildStructure

def referenced[PR <: ProjectReference](definitions: Seq[ProjectDefinition[PR]]): Seq[PR]

def resolveAll(builds: Map[URI, sbt.PartBuildUnit]): Map[URI, sbt.LoadedBuildUnit]

def resolveBase(against: File): (Project) ⇒ Project

def resolveProjects(uri: URI, unit: sbt.PartBuildUnit, rootProject: (URI) ⇒ String): sbt.LoadedBuildUnit

def resolveProjects(loaded: sbt.PartBuild): sbt.LoadedBuild

def setDefinitionKey[T](tk: Task[T], key: Def.ScopedKey[_]): Task[T]

def structureIndex(data: Settings[Scope], settings: Seq[Def.Setting[_]], extra: (KeyIndex) ⇒ BuildUtil[_], projects: Map[URI, LoadedBuildUnit]): sbt.StructureIndex

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

def transformProjectOnly(uri: URI, rootProject: (URI) ⇒ String, settings: Seq[Def.Setting[_]]): Seq[Def.Setting[_]]

def transformSettings(thisScope: Scope, uri: URI, rootProject: (URI) ⇒ String, settings: Seq[Def.Setting[_]]): Seq[Def.Setting[_]]

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

val LoadBuildConfiguration: sbt.LoadBuildConfiguration.type

def baseImports: Seq[String]

def binaryPlugins(classpath: Seq[File], loader: ClassLoader): Seq[String]

def buildUtil(root: URI, units: Map[URI, sbt.LoadedBuildUnit], keyIndex: KeyIndex, data: Settings[Scope]): BuildUtil[ResolvedProject]

def checkCycles(units: Map[URI, sbt.LoadedBuildUnit]): Unit

def configurations(srcs: Seq[File], eval: () ⇒ Eval, imports: Seq[String]): (ClassLoader) ⇒ LoadedSbtFile

def discover(analysis: Analysis, subclasses: String*): Seq[String]

def extractSettings(plugins: Seq[Plugin]): (Seq[Def.Setting[_]], Seq[Def.Setting[_]], Seq[Def.Setting[_]])

def findDefinitions(analysis: Analysis): Seq[String]

def findPlugins(analysis: Analysis): Seq[String]

def getImports(unit: sbt.BuildUnit): Seq[String]

def getPluginNames(classpath: Seq[Attributed[File]], loader: ClassLoader): Seq[String]

def importAll(values: Seq[String]): Seq[String]

def importAllRoot(values: Seq[String]): Seq[String]

def loadDefinition(loader: ClassLoader, definition: String): Build

def loadDefinitions(loader: ClassLoader, defs: Seq[String]): Seq[Build]

def loadPlugin(pluginName: String, loader: ClassLoader): Plugin

def loadPlugins(loader: ClassLoader, pluginNames: Seq[String]): Seq[Plugin]

def onClasspath(classpath: Seq[File])(url: URL): Boolean

def pluginGlobalSettings(loaded: sbt.LoadedBuild): Seq[Def.Setting[_]]

def rootedName(s: String): String