sponge

implicit abstract def F: MonadError[F, CommandFailureNEL]

abstract val defaultCommandSuccess: Result

abstract def sendCommandHelp(title: (HelpCommands.this)#Title, source: RootSender, command: (HelpCommands.this)#StaticChildCommand[_, _], path: List[String]): F[(HelpCommands.this)#CommandSuccess]

abstract def sendMultipleCommandHelp(title: (HelpCommands.this)#Title, source: RootSender, commands: Set[(HelpCommands.this)#ChildCommand[_, _]]): F[(HelpCommands.this)#CommandSuccess]

abstract def tabExtraToRunExtra(extra: TabExtra): RunExtra

object Alias

Helper for creating an alias when registering a command.

object Command

val CommandError: scammander.CommandError.type

val CommandSyntaxError: scammander.CommandSyntaxError.type

val CommandUsageError: scammander.CommandUsageError.type

object Description

Helper for creating an description when registering a command.

val FtoSF: ~>[F, SF]

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

def SF: Monad[SF]

object Targeter

object UserValidator

implicit val allPlayerParam: (SpongeParameter.this)#Parameter[Set[Player]]

implicit val bigDecimalParam: (NormalParameters.this)#Parameter[BigDecimal]

implicit val bigIntParam: (NormalParameters.this)#Parameter[BigInt]

implicit val boolParam: (NormalParameters.this)#Parameter[Boolean]

implicit def booleanFlagParameter[Name <: String](implicit witness: Aux[Name]): (FlagParameters.this)#Parameter[(FlagParameters.this)#BooleanFlag[Name]]

implicit val byteParam: (NormalParameters.this)#Parameter[Byte]

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

implicit def cConsParam[H, T <: Coproduct](implicit hParam: Lazy[(scammander.ParameterDeriver.this)#Parameter[H]], tParam: Lazy[(scammander.ParameterDeriver.this)#Parameter[T]]): (scammander.ParameterDeriver.this)#Parameter[:+:[H, T]]

implicit val cNilParam: (scammander.ParameterDeriver.this)#Parameter[CNil]

implicit def catalogTypeHasName[A <: CatalogType]: (SpongeParameter.this)#HasName[A]

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

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

implicit val dataContainerParam: (SpongeParameter.this)#Parameter[DataContainer]

implicit val dateTimeOrNowParam: (OrNowParameter.this)#Parameter[(OrNowParameter.this)#Or[LocalDateTime, (OrNowParameter.this)#Now]]

implicit val dateTimeParam: (NormalParameters.this)#Parameter[LocalDateTime]

implicit val doubleParam: (NormalParameters.this)#Parameter[Double]

implicit val durationParam: (NormalParameters.this)#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]): (SpongeParameter.this)#Parameter[Set[A]]

implicit def entitySender[A <: Entity](implicit arg0: Typeable[A]): (SpongeValidators.this)#UserValidator[A]

implicit def flagsParameter[A, B](implicit flagsParam: (FlagParameters.this)#Parameter[A], paramParam: (FlagParameters.this)#Parameter[B]): (FlagParameters.this)#Parameter[(FlagParameters.this)#Flags[A, B]]

implicit val floatParam: (NormalParameters.this)#Parameter[Float]

def genParam[A, Gen](implicit gen: Aux[A, Gen], genParam: Lazy[(ParameterLabelledDeriver.this)#Parameter[Gen]]): (ParameterLabelledDeriver.this)#Parameter[A]

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

implicit def hConsParam[H, T <: HList](implicit hParam: Lazy[(scammander.ParameterDeriver.this)#Parameter[H]], tParam: Lazy[(scammander.ParameterDeriver.this)#Parameter[T]]): (scammander.ParameterDeriver.this)#Parameter[::[H, T]]

implicit val hNilParam: (scammander.ParameterDeriver.this)#Parameter[HNil]

def helpCommand(title: (HelpCommands.this)#Title, commands: ⇒ Set[(HelpCommands.this)#ChildCommand[_, _]]): (HelpCommands.this)#Command[RootSender, (HelpCommands.this)#ZeroOrMore[String]]

implicit val intParam: (NormalParameters.this)#Parameter[Int]

implicit val ipParam: (SpongeParameter.this)#Parameter[InetAddress]

implicit val ipSender: (SpongeValidators.this)#UserValidator[InetAddress]

implicit val locationParam: (SpongeParameter.this)#Parameter[Set[Location[World]]]

implicit val locationSender: (SpongeValidators.this)#UserValidator[Location[World]]

implicit val longParam: (NormalParameters.this)#Parameter[Long]

def mkSingle[A](parName: String, parser: (String) ⇒ F[A], possibleSuggestions: () ⇒ Seq[String]): (NormalParameters.this)#Parameter[A]

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

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

implicit val notUsedParam: Parameter[NotUsed]

implicit def onlyOneParam[A](implicit setParam: (HelperParameters.this)#Parameter[Set[A]]): (HelperParameters.this)#Parameter[(HelperParameters.this)#OnlyOne[A]]

implicit def optionParam[A](implicit param: (HelperParameters.this)#Parameter[A]): (HelperParameters.this)#Parameter[Option[A]]

implicit def orSource[Base](implicit parameter: (OrParameters.this)#Parameter[Base], validator: (OrParameters.this)#UserValidator[Base]): (OrParameters.this)#Parameter[(OrParameters.this)#OrSource[Base]]

implicit def orTargetParam[Base](implicit parameter: (SpongeOrParameter.this)#Parameter[Base], targeter: (SpongeOrParameter.this)#Targeter[Base]): (SpongeOrParameter.this)#Parameter[(SpongeOrParameter.this)#OrTarget[Base]]

implicit val playerHasName: (SpongeParameter.this)#HasName[Player]

implicit val playerParam: (SpongeParameter.this)#Parameter[Player]

implicit val playerSender: (SpongeValidators.this)#UserValidator[Player]

implicit val pluginHasName: (SpongeParameter.this)#HasName[PluginContainer]

implicit val pluginParam: (SpongeParameter.this)#Parameter[Set[PluginContainer]]

def primitiveParam[A](parName: String, s: (String) ⇒ A): (NormalParameters.this)#Parameter[A]

implicit val rawCmdArgsParam: Parameter[List[RawCmdArg]]

implicit val remainingAsStringParam: (HelperParameters.this)#Parameter[(HelperParameters.this)#RemainingAsString]

implicit val shortParam: (NormalParameters.this)#Parameter[Short]

implicit val stringParam: (NormalParameters.this)#Parameter[String]

implicit val unitParam: (NormalParameters.this)#Parameter[Unit]

implicit val urlParam: (NormalParameters.this)#Parameter[URL]

implicit val userParam: (SpongeParameter.this)#Parameter[Set[User]]

implicit val userSender: (SpongeValidators.this)#UserValidator[User]

implicit val uuidParam: (NormalParameters.this)#Parameter[UUID]

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

implicit val vector3dParam: (SpongeParameter.this)#Parameter[Vector3d]

implicit val vector3dSender: (SpongeValidators.this)#UserValidator[Vector3d]

implicit val worldHasName: (SpongeParameter.this)#HasName[WorldProperties]

implicit val worldParam: (SpongeParameter.this)#Parameter[Set[WorldProperties]]