ExecConfig

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def actorSystemName: String

def asDuration(key: String): Duration

def asFiniteDuration(key: String): FiniteDuration

final def asInstanceOf[T0]: T0

def asList(path: String, separator: Option[String]): List[String]

implicit def asRichConfig(c: Config): RichConfig

def chunkSize: Int

implicit lazy val clientConfig: ClientConfig

def clone(): AnyRef

def collectAsMap: Map[String, String]

def collectAsStrings: List[(String, String)]

val config: Config

def defaultEnv: Map[String, String]

lazy val defaultExchangeClient: ExchangeRestClient

def defaultFrameLength: Int

def defaultUIPath: String

def describe(implicit opts: ConfigRenderOptions): String

def enableCache: Boolean

def enableSupportRoutes: Boolean

def entries: Set[Entry[String, ConfigValue]]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def errorLimit: Option[Int]

def eventMonitor: SystemEventMonitor

def eventMonitorConfig: EventMonitorConfig

def exchangeClient: ExchangeRestClient

lazy val exchangeConfig: ExchangeServerConfig

def execSubscriptions(resolvedLocation: HostLocation): SubscriptionGroup

def executionClient(): ExecutionClient

def filterNot(path: (String) ⇒ Boolean): Config

final def getClass(): Class[_]

def hashCode(): Int

def healthUpdateFrequency: FiniteDuration

def host: String

def hostResolver: HostResolver

def housekeeping: HousekeepingConfig

def includeExchangeRoutes: Boolean

def includeSwaggerRoutes: Boolean

def initialRequest: Int

def intersect(other: Config): Config

final def isInstanceOf[T0]: Boolean

def json: String

def landingPage: String

def launchBrowser: Boolean

def location: HostLocation

final def ne(arg0: AnyRef): Boolean

def newConfig(overrides: Map[String, String]): Config

def newSystem(name: String): AkkaImplicits

def newWorkerRoutes(exchange: Exchange): DynamicWorkerRoutes

def nextActorSystemName(): String

final def notify(): Unit

final def notifyAll(): Unit

def or(other: Config): Config

def origins: List[URL]

def pathRoots: List[String]

def paths: List[String]

def port: Int

def remoteRunner(implicit mat: Materializer = serverImplicits.materializer): RemoteRunner

def routes(exchangeRoutes: Option[Route]): Route

def runSubscription(resolvedLocation: HostLocation): WorkSubscription

def runWithRoutes[T](routes: Route, svc: T): Future[RunningService[ServerConfig, T]]

lazy val serverImplicits: AkkaImplicits

def show(options: ConfigRenderOptions): Option[String]

def start(): Future[RunningService[ExecConfig, ExecutionRoutes]]

Convenience method for starting an exec service.

Service(config)

config.newService

userArgs => config => started/running service

def startWorker(): Future[RunningWorker]

def subscription: WorkSubscription

lazy val subscriptionConfig: SubscriptionConfig

def summary(pathFilter: (String) ⇒ Boolean): List[StringEntry]

def swaggerApiClasses: Set[Class[_]]

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

def toString(): String

def unique: Config

def uniquePaths: List[String]

def unmarshalTimeout: FiniteDuration

implicit def uploadTimeout: FiniteDuration

lazy val uploads: PathConfig

def uploadsDir: Path

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def waitOnUserInput: Boolean

def withFallback(fallback: Config): ExecConfig

def withOverrides(overrides: Config): ExecConfig

def withPaths(paths: List[String]): Config

def withPaths(first: String, theRest: String*): Config

def withUserArgs(args: Array[String], unrecognizedArg: (String) ⇒ Config): Config

def without(paths: TraversableOnce[String]): Config

def without(firstPath: String, theRest: String*): Config

def without(other: Config): Config

def withoutSystem: Config

def workspaceClient: WorkspaceClient

def finalize(): Unit