sbt

val :+:: HCons.type

val :^:: KCons.type

final val Compile: Configuration

object CrossBuilding

The idea here is to be able to define a "sbtVersion in sbtPlugin" which directs the dependencies of the plugin to build to the specified sbt plugin version.

final val Default: Configuration

final val Docs: Configuration

final val GlobalScope: Scope

final val IntegrationTest: Configuration

final val Optional: Configuration

final val Provided: Configuration

final val Runtime: Configuration

object SbtCrossCompat

object SbtPluginCross

object SbtScriptedSupport

final val Sources: Configuration

final val Test: Configuration

final val ThisScope: Scope

def abs: (java.io.File) ⇒ Option[java.io.File]

def addArtifact(artifact: sbt.Def.Initialize[Artifact], taskDef: sbt.Def.Initialize[Task[java.io.File]]): sbt.Def.SettingsDefinition

def addArtifact(a: Artifact, taskDef: TaskKey[java.io.File]): sbt.Def.SettingsDefinition

def addCommandAlias(name: String, value: String): Seq[sbt.Def.Setting[(State) ⇒ State]]

def addCompilerPlugin(dependency: ModuleID): sbt.Def.Setting[Seq[ModuleID]]

def addSbtPlugin(dependency: ModuleID): sbt.Def.Setting[Seq[ModuleID]]

def addSbtPlugin(dependency: ModuleID, sbtVersion: String): sbt.Def.Setting[Seq[ModuleID]]

def addSbtPlugin(dependency: ModuleID, sbtVersion: String, scalaVersion: String): sbt.Def.Setting[Seq[ModuleID]]

def allSubpaths(base: java.io.File): Traversable[(java.io.File, String)]

implicit def alternative[A, B](f: (A) ⇒ Option[B]): Alternative[A, B]

final def alternatives[A, B](alts: Seq[(A) ⇒ Option[B]]): (A) ⇒ Option[B]

def artifactFilter(name: NameFilter, type: NameFilter, extension: NameFilter, classifier: NameFilter): ArtifactFilter

val basic: (java.io.File) ⇒ Option[String]

implicit final def binaryPipeTask[Key](in: Task[_])(implicit streams: Task[TaskStreams[Key]], key: (Task[_]) ⇒ Key): BinaryPipe

implicit def builderToProcess(builder: java.lang.ProcessBuilder): ProcessBuilder

implicit def buildersToProcess[T](builders: Seq[T])(implicit convert: (T) ⇒ SourcePartialBuilder): Seq[SourcePartialBuilder]

implicit def classpathDependency[T](p: T)(implicit arg0: (T) ⇒ ProjectReference): ClasspathDependency

def compilerPlugin(dependency: ModuleID): ModuleID

def config(s: String): Configuration

implicit def configDependencyConstructor[T](p: T)(implicit arg0: (T) ⇒ ProjectReference): Constructor

def configurationFilter(name: NameFilter): ConfigurationFilter

final def const[A, B](b: B): (A) ⇒ B

final def constant[T](t: T): Task[T]

def externalIvyFile(file: sbt.Def.Initialize[java.io.File], iScala: sbt.Def.Initialize[Option[IvyScala]]): sbt.Def.Setting[Task[ModuleSettings]]

def externalIvySettings(file: sbt.Def.Initialize[java.io.File], addMultiResolver: Boolean): sbt.Def.Setting[Task[IvyConfiguration]]

def externalIvySettingsURI(uri: sbt.Def.Initialize[java.net.URI], addMultiResolver: Boolean): sbt.Def.Setting[Task[IvyConfiguration]]

def externalIvySettingsURL(url: java.net.URL, addMultiResolver: Boolean): sbt.Def.Setting[Task[IvyConfiguration]]

def externalPom(file: sbt.Def.Initialize[java.io.File], iScala: sbt.Def.Initialize[Option[IvyScala]]): sbt.Def.Setting[Task[ModuleSettings]]

def fail: (Any) ⇒ Nothing

def file(s: String): File

implicit def fileToProcess(file: java.io.File): FilePartialBuilder

implicit def filesToFinder(cc: Traversable[java.io.File]): PathFinder

def filterKeys(ss: Seq[sbt.Def.Setting[_]], transitive: Boolean)(f: (sbt.Def.ScopedKey[_]) ⇒ Boolean): Seq[sbt.Def.Setting[_]]

def flat(newDirectory: java.io.File): (java.io.File) ⇒ Option[java.io.File]

val flat: (java.io.File) ⇒ Option[String]

def flatRebase(newBase: String): (java.io.File) ⇒ Option[String]

def fullRunInputTask(scoped: InputKey[Unit], config: Configuration, mainClass: String, baseArguments: String*): sbt.Def.Setting[InputTask[Unit]]

def fullRunTask(scoped: TaskKey[Unit], config: Configuration, mainClass: String, arguments: String*): sbt.Def.Setting[Task[Unit]]

def getForParser[P, T](task: TaskKey[T])(init: (State, Option[T]) ⇒ Parser[P]): sbt.Def.Initialize[(State) ⇒ Parser[P]]

def getForParserI[P, T](task: TaskKey[T])(init: sbt.Def.Initialize[(State, Option[T]) ⇒ Parser[P]]): sbt.Def.Initialize[(State) ⇒ Parser[P]]

def getFromContext[T](task: TaskKey[T], context: sbt.Def.ScopedKey[_], s: State): Option[T]

def getPrevious[T](task: TaskKey[T]): sbt.Def.Initialize[Task[Option[T]]]

implicit def globFilter(expression: String): NameFilter

final def idFun[T]: (T) ⇒ T

final def idK[M[_]]: ~>[M, M]

def inAggregates(ref: ProjectReference, transitive: Boolean, includeRoot: Boolean): ProjectFilter

def inAnyConfiguration: sbt.ScopeFilter.ConfigurationFilter

def inAnyProject: ProjectFilter

def inAnyTask: TaskFilter

def inConfig(conf: Configuration)(ss: Seq[sbt.Def.Setting[_]]): Seq[sbt.Def.Setting[_]]

def inConfigurations(configs: Configuration*): sbt.ScopeFilter.ConfigurationFilter

def inDependencies(ref: ProjectReference, transitive: Boolean, includeRoot: Boolean): ProjectFilter

def inGlobalConfiguration: sbt.ScopeFilter.ConfigurationFilter

def inGlobalProject: ProjectFilter

def inGlobalTask: TaskFilter

def inProjects(projects: ProjectReference*): ProjectFilter

def inScope(scope: Scope)(ss: Seq[sbt.Def.Setting[_]]): Seq[sbt.Def.Setting[_]]

def inTask(t: Scoped)(ss: Seq[sbt.Def.Setting[_]]): Seq[sbt.Def.Setting[_]]

def inTasks(tasks: Scoped*): TaskFilter

def initScope[T](s: Scope, i: sbt.Def.Initialize[T]): sbt.Def.Initialize[T]

def initScoped[T](sk: sbt.Def.ScopedKey[_], i: sbt.Def.Initialize[T]): sbt.Def.Initialize[T]

final def inlineTask[T](value: T): Task[T]

def inputKey[T](description: String): InputKey[T]

implicit final def iterableTask[S](in: Seq[S]): ForkTask[S, Seq]

implicit final def joinAnyTasks(in: Seq[Task[_]]): JoinTask[Any, Seq]

implicit final def joinTasks[S](in: Seq[Task[S]]): JoinTask[S, Seq]

final val left: ~>[Id, [B]Left[B, Nothing]]

implicit final def linesTask[Key](in: Task[_])(implicit streams: Task[TaskStreams[Key]], key: (Task[_]) ⇒ Key): TaskLines

def loadForParser[P, T](task: TaskKey[T])(f: (State, Option[T]) ⇒ Parser[P])(implicit format: Format[T]): sbt.Def.Initialize[(State) ⇒ Parser[P]]

def loadForParserI[P, T](task: TaskKey[T])(init: sbt.Def.Initialize[(State, Option[T]) ⇒ Parser[P]])(implicit format: Format[T]): sbt.Def.Initialize[(State) ⇒ Parser[P]]

def loadFromContext[T](task: TaskKey[T], context: sbt.Def.ScopedKey[_], s: State)(implicit f: Format[T]): Option[T]

def loadPrevious[T](task: TaskKey[T])(implicit f: Format[T]): sbt.Def.Initialize[Task[Option[T]]]

implicit def macroValueIn[T](in: InputTask[T]): InputEvaluated[T]

implicit def macroValueT[T](in: Task[T]): MacroValue[T]

implicit def maybeToOption[S](m: Maybe[S]): Option[S]

def moduleFilter(organization: NameFilter, name: NameFilter, revision: NameFilter): ModuleFilter

implicit final def moduleIDConfigurable(m: ModuleID): ModuleIDConfigurable

implicit final def multInputTask[K[L[X]]](tasks: K[Task])(implicit a: AList[K]): MultiInTask[K]

implicit final def multT2Task[A, B](in: (Task[A], Task[B])): MultiInTask[[L[x]](L[A], L[B])]

def nestCon[M[_], N[_], G[_]](f: ~>[M, N]): ~>[[T]M[G[T]], [T]N[G[T]]]

def noTestCompletion(config: Configuration): sbt.Def.Setting[_]

final def nop: Task[Unit]

def normalizeBase(base: String): String

def overrideConfigs(cs: Configuration*)(configurations: Seq[Configuration]): Seq[Configuration]

implicit def parserToInput[T](in: Parser[T]): ParserInput[T]

implicit final def pipeToProcess[Key](t: Task[_])(implicit streams: Task[TaskStreams[Key]], key: (Task[_]) ⇒ Key): ProcessPipe

implicit def processToTask(p: ProcessBuilder)(implicit streams: Task[TaskStreams[_]]): Task[Int]

def project: Project

def rebase(oldBase: java.io.File, newBase: java.io.File): (java.io.File) ⇒ Option[java.io.File]

def rebase(oldBases: Iterable[java.io.File], newBase: java.io.File, zero: (java.io.File) ⇒ Option[java.io.File]): (java.io.File) ⇒ Option[java.io.File]

def rebase(oldBase: java.io.File, newBase: String): (java.io.File) ⇒ Option[String]

def relativeTo(bases: Iterable[java.io.File], zero: (java.io.File) ⇒ Option[String]): (java.io.File) ⇒ Option[String]

def relativeTo(base: java.io.File): (java.io.File) ⇒ Option[String]

def resolve(newDirectory: java.io.File): (java.io.File) ⇒ Option[java.io.File]

implicit def richAttributed(s: Seq[Attributed[java.io.File]]): RichAttributed

implicit def richFile(file: java.io.File): RichFile

implicit def richFiles(s: Seq[java.io.File]): RichFiles

implicit def richInitialize[T](i: sbt.Def.Initialize[T]): RichInitialize[T]

implicit def richInitializeInputTask[T](init: sbt.Def.Initialize[InputTask[T]]): RichInitializeInputTask[T]

implicit def richInitializeTask[T](init: sbt.Def.Initialize[Task[T]]): RichInitializeTask[T]

implicit def richPathFinder(s: PathFinder): RichPathFinder

implicit def richTaskSessionVar[T](init: sbt.Def.Initialize[Task[T]]): RichTaskSessionVar[T]

final val right: ~>[Id, [B]Right[Nothing, B]]

def runInputTask(config: Configuration, mainClass: String, baseArguments: String*): sbt.Def.Initialize[InputTask[Unit]]

def runTask(config: Configuration, mainClass: String, arguments: String*): sbt.Def.Initialize[Task[Unit]]

def selectSubpaths(base: java.io.File, filter: FileFilter): Traversable[(java.io.File, String)]

def settingKey[T](description: String): SettingKey[T]

implicit def settingKeyAll[T](key: sbt.Def.Initialize[T]): SettingKeyAll[T]

implicit def singleFileFinder(file: java.io.File): PathFinder

implicit final def singleInputTask[S](in: Task[S]): SingleInTask[S]

final val some: ~>[Id, Some]

implicit def stateParserToInput[T](in: (State) ⇒ Parser[T]): ParserInput[T]

implicit def stringSeqToProcess(command: Seq[String]): ProcessBuilder

implicit def stringToProcess(command: String): ProcessBuilder

final def task[T](f: ⇒ T): Task[T]

def taskKey[T](description: String): TaskKey[T]

implicit def taskKeyAll[T](key: sbt.Def.Initialize[Task[T]]): TaskKeyAll[T]

implicit final def textPipeTask[Key](in: Task[_])(implicit streams: Task[TaskStreams[Key]], key: (Task[_]) ⇒ Key): TextPipe

def toError(o: Option[String]): Unit

implicit def toFn1[A, B](f: (A) ⇒ B): Fn1[A, B]

implicit final def toGroupID(groupID: String): GroupID

implicit final def toRepositoryName(name: String): RepositoryName

implicit final def toTask[T](f: () ⇒ T): Task[T]

implicit final def toTaskInfo[S](in: Task[S]): TaskInfo[S]

implicit final def toTasks[S](in: Seq[() ⇒ S]): Seq[Task[S]]

def total[A, B](f: (A) ⇒ B): (A) ⇒ Some[B]

def transparent: (Any) ⇒ Option[Nothing]

implicit final def upcastTask[A >: B, B](t: Task[B]): Task[A]

def uri(s: String): URI

def url(s: String): URL

implicit def urlToProcess(url: java.net.URL): URLPartialBuilder

val CommandSupport: CommandStrings.type

def inputTask[T](f: (TaskKey[Seq[String]]) ⇒ sbt.Def.Initialize[Task[T]]): sbt.Def.Initialize[InputTask[T]]

def seq(settings: sbt.Def.Setting[_]*): sbt.Def.SettingsDefinition

implicit def xmlToProcess(command: Elem): ProcessBuilder