Auto wiring

When you use constructor injection to inject dependencies of your component and they are also registered in the container auto-wiring enables you to resolve this components just with one call to resolve method without providing its dependencies as arguments - container will resolve them for you.

class PresenterImp: Presenter {
    init(view: ViewOutput, interactor: Interactor, router: Router) { ... }
    ...
}

container.register { RouterImp() as Router }
container.register { View() as ViewOutput }
container.register { InteractorImp() as Interactor }
container.register { PresenterImp(view: $0, interactor: $1, router: $2) as Presenter }

let presenter = try! container.resolve() as Presenter

Auto-wiring uses Swift Type Inference to infer types of constructor arguments and if they all are registered in container, they will be automatically resolved.

At the same time you are able to resolve the component using runtime arguments:

let view = try! container.resolve() as ViewOutput
let interactor = try! container.resolve() as Interactor
let router = try! container.resolve() as Router

//without auto-wiring
let presenter = try! container.resolve(withArguments: view, interactor, router) as Presenter

Auto-wiring saves all these calls to resolve each constructor argument.

Alternatively you could register factory that does not accept runtime arguments but resolves constructor arguments by itself:

container.register { 
    try PresenterImp(
        view: container.resolve(), 
        interactor: container.resolve(),
        router: container.resolve()
    ) as Presenter 
}

In this case auto-wiring again lets you avoid this repetitive calls to resolve method.