SpongeBaseAll

abstract def G: MonadError[G, CommandFailureNEL]

abstract def runG[A](computation: G[A]): Either[CommandFailureNEL, A]

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

object Alias

Helper for creating an alias when registering a command.

val ChildCommand: ComplexChildCommand.type

object Description

Helper for creating an description when registering a command.

def GE: ApplicativeHandle[G, CommandFailureNEL]

val HasName: scammander.HasName.type

object Help

Helper for creating a help when registering a command.

object OnlyOne extends Serializable

object Parameter

object Permission

Helper for creating a alias when registering a command.

val RawCmdArg: scammander.RawCmdArg.type

object Result

object Targeter

implicit val allPlayerParam: Parameter[Set[Player]]

final def asInstanceOf[T0]: T0

implicit val bigDecimalParam: Parameter[BigDecimal]

implicit val bigIntParam: Parameter[BigInt]

implicit val boolParam: Parameter[Boolean]

implicit def booleanFlagParameter[Name <: String](implicit witness: Aux[Name]): Parameter[BooleanFlag[Name]]

implicit val byteParam: Parameter[Byte]

implicit def cConsLabelledParam[HK <: Symbol, HV, T <: Coproduct](implicit hName: Aux[HK], hParam: Lazy[Parameter[HV]], tParam: Lazy[Parameter[T]]): Parameter[:+:[FieldType[HK, HV], T]]

implicit def cConsParam[H, T <: Coproduct](implicit hParam: Lazy[Parameter[H]], tParam: Lazy[Parameter[T]]): Parameter[:+:[H, T]]

implicit val cNilParam: Parameter[CNil]

implicit def catalogTypeHasName[A <: CatalogType]: HasName[A]

implicit def catalogedParam[A <: CatalogType](implicit classTag: ClassTag[A], typeable: Typeable[A]): Parameter[Set[A]]

def clone(): AnyRef

def createCommand[Sender, Param](runCmd: (Sender, RunExtra, Param) ⇒ G[CommandSuccess], childSet: Set[ChildCommand])(implicit arg0: UserValidator[Sender], arg1: Parameter[Param]): Command[Sender, Param]

def createCommandHelp(source: CommandSource, commandName: String, fullCommandName: String, command: StaticChildCommand, detail: Boolean, indent: Int = 0, isIndentEnd: Boolean = false): Seq[Text]

implicit val dataContainerParam: Parameter[DataContainer]

implicit val dateTimeOrNowParam: Parameter[Or[LocalDateTime, Now]]

implicit val dateTimeParam: Parameter[LocalDateTime]

val defaultCommandSuccess: Int

implicit val doubleParam: Parameter[Double]

implicit val durationParam: Parameter[Duration]

def dynamicCommandOf[Args, Identifier, Sender, Param](command: (Args) ⇒ Command[Sender, Param], identifier: Identifier): GetDynamicCommandType[Args, Identifier, Sender, Param]

implicit def dynamicCommandParameter[Args, Identifier, Sender, Param](implicit cmd: NamedCommand[Args, Identifier, Sender, Param], validator: UserValidator[Sender], parameter: Parameter[Param]): Parameter[DynamicCommand[Args, Identifier, Sender, Param]]

implicit def entityParam[A <: Entity](implicit typeable: Typeable[A]): Parameter[Set[A]]

implicit def entitySender[A <: Entity](implicit arg0: Typeable[A]): UserValidator[A]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

implicit def flagsParameter[A, B](implicit flagsParam: Parameter[A], paramParam: Parameter[B]): Parameter[Flags[A, B]]

implicit val floatParam: Parameter[Float]

def genParam[A, Gen](implicit gen: Aux[A, Gen], genParam: Lazy[Parameter[Gen]]): Parameter[A]

final def getClass(): Class[_]

implicit def hConsLabelledParam[HK <: Symbol, HV, T <: HList](implicit hName: Aux[HK], hParam: Lazy[Parameter[HV]], tParam: Lazy[Parameter[T]]): Parameter[::[FieldType[HK, HV], T]]

implicit def hConsParam[H, T <: HList](implicit hParam: Lazy[Parameter[H]], tParam: Lazy[Parameter[T]]): Parameter[::[H, T]]

implicit val hNilParam: Parameter[HNil]

def hashCode(): Int

def helpCommand(title: Title, commands: ⇒ Set[ChildCommand])(implicit G: MonadError[G, String]): Command[RootSender, ZeroOrMore[String]]

implicit val intParam: Parameter[Int]

implicit val ipParam: Parameter[InetAddress]

implicit val ipSender: UserValidator[InetAddress]

final def isInstanceOf[T0]: Boolean

implicit val locationParam: Parameter[Set[Location[World]]]

implicit val locationSender: UserValidator[Location[World]]

implicit val longParam: Parameter[Long]

def mkSingle[A](parName: String, parser: (String) ⇒ A, possibleSuggestions: Eval[Seq[String]]): Parameter[A]

implicit def namedParam[Name <: String, A](implicit paramParam: Parameter[A], witness: Aux[Name]): Parameter[Named[Name, A]]

final def ne(arg0: AnyRef): Boolean

implicit def needPermissionParam[S <: String, A](implicit param0: Parameter[A], w: Aux[S]): Parameter[NeedPermission[S, A]]

implicit val notUsedParam: Parameter[NotUsed]

final def notify(): Unit

final def notifyAll(): Unit

implicit def onlyOneParam[A](implicit setParam: Parameter[Set[A]]): Parameter[OnlyOne[A]]

implicit def optionParam[A](implicit param: Parameter[A]): Parameter[Option[A]]

implicit def orSource[Base](implicit parameter: Parameter[Base], validator: UserValidator[Base]): Parameter[OrSource[Base]]

implicit def orTargetParam[Base](implicit parameter: Parameter[Base], targeter: Targeter[Base]): Parameter[OrTarget[Base]]

implicit val playerHasName: HasName[Player]

implicit val playerParam: Parameter[Player]

implicit val playerSender: UserValidator[Player]

implicit val pluginHasName: HasName[PluginContainer]

implicit val pluginParam: Parameter[Set[PluginContainer]]

def primitiveParam[A](parName: String, s: (String) ⇒ A): Parameter[A]

implicit val rawCmdArgsParam: Parameter[List[RawCmdArg]]

implicit val remainingAsStringParam: Parameter[RemainingAsString]

implicit def rootValidator: UserValidator[RootSender]

def sendCommandHelp(title: Title, source: RootSender, command: StaticChildCommand, path: List[String]): G[CommandSuccess]

def sendMultipleCommandHelp(title: Title, source: RootSender, commands: Set[ChildCommand]): G[CommandSuccess]

implicit val shortParam: Parameter[Short]

implicit val stringParam: Parameter[String]

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

def tabExtraToRunExtra(extra: Option[Location[World]]): Unit

def toString(): String

implicit val unitParam: Parameter[Unit]

implicit val urlParam: Parameter[URL]

implicit val userParam: Parameter[Set[User]]

implicit val userSender: UserValidator[User]

implicit val uuidParam: Parameter[UUID]

implicit def valueFlagParameter[Name <: String, A](implicit witness: Aux[Name], flagParam: Parameter[A]): Parameter[ValueFlag[Name, A]]

implicit val vector3dParam: Parameter[Vector3d]

implicit val vector3dSender: UserValidator[Vector3d]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

implicit val worldHasName: HasName[WorldProperties]

implicit val worldParam: Parameter[Set[WorldProperties]]