sbt

val :+:: sbt.HCons.type

val :^:: sbt.KCons.type

final val Compile: Configuration

object CrossBuilding extends AnyRef

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 SbtPluginCross extends AnyRef

object SbtScriptedSupport extends AnyRef

final val Sources: Configuration

final val Test: Configuration

final val ThisScope: Scope

def abs: (File) ⇒ Option[File]

implicit final def actionToTask[T](a: Action[T]): Task[T]

def addArtifact(artifact: Initialize[Artifact], taskDef: Initialize[Task[File]]): SettingsDefinition

def addArtifact(a: Artifact, taskDef: TaskKey[File]): SettingsDefinition

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

def addCompilerPlugin(dependency: ModuleID): Setting[Seq[ModuleID]]

def addSbtPlugin(dependency: ModuleID): Setting[Seq[ModuleID]]

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

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

def allSubpaths(base: File): Traversable[(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: (File) ⇒ Option[String]

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

implicit def builderToProcess(builder: 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: Initialize[File], iScala: Initialize[Option[IvyScala]]): Setting[Task[ModuleSettings]]

def externalIvySettings(file: Initialize[File], addMultiResolver: Boolean): Setting[Task[IvyConfiguration]]

def externalIvySettingsURI(uri: Initialize[URI], addMultiResolver: Boolean): Setting[Task[IvyConfiguration]]

def externalIvySettingsURL(url: URL, addMultiResolver: Boolean): Setting[Task[IvyConfiguration]]

def externalPom(file: Initialize[File], iScala: Initialize[Option[IvyScala]]): Setting[Task[ModuleSettings]]

implicit final def f2ToHfun[A, B, R](f: (A, B) ⇒ R): (:+:[A, :+:[B, HNil]]) ⇒ R

implicit final def f3ToHfun[A, B, C, R](f: (A, B, C) ⇒ R): (:+:[A, :+:[B, :+:[C, HNil]]]) ⇒ R

def fail: (Any) ⇒ Nothing

def file(s: String): File

implicit def fileToProcess(file: File): FilePartialBuilder

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

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

def flat(newDirectory: File): (File) ⇒ Option[File]

val flat: (File) ⇒ Option[String]

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

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

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

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

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

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

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

implicit def globFilter(expression: String): NameFilter

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

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

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

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

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

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

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

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

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

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

implicit final def joinAnyTasks(in: Seq[sbt.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: sbt.Task[_])(implicit streams: Task[TaskStreams[Key]], key: (sbt.Task[_]) ⇒ Key): TaskLines

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

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

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

def loadPrevious[T](task: TaskKey[T])(implicit f: Format[T]): Initialize[Task[Option[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[In <: HList](tasks: Tasks[In]): MultiInTask[In]

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

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

final def nop: Task[Unit]

def normalizeBase(base: String): String

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

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

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

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

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

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

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

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

def resolve(newDirectory: File): (File) ⇒ Option[File]

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

implicit def richFile(file: File): RichFile

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

implicit def richPathFinder(s: PathFinder): RichPathFinder

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

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

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

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

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

implicit def singleFileFinder(file: File): PathFinder

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

final val some: ~>[Id, Some]

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

implicit def stringToProcess(command: String): ProcessBuilder

implicit final def t2ToMulti[A, B](t: (Task[A], Task[B])): MultiInTask[:+:[A, :+:[B, HNil]]]

implicit final def t3ToMulti[A, B, C](t: (Task[A], Task[B], Task[C])): MultiInTask[:+:[A, :+:[B, :+:[C, HNil]]]]

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

implicit final def textPipeTask[Key](in: sbt.Task[_])(implicit streams: Task[TaskStreams[Key]], key: (sbt.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: URL): URLPartialBuilder

implicit def xmlToProcess(command: Elem): ProcessBuilder

val CommandSupport: sbt.CommandStrings.type