extension Container {
    static let services = Container(ContainerConfigurator.services)
    static let assemblies = Container(ContainerConfigurator.assemblies)
    static let appearance = Container(ContainerConfigurator.appearance)
}

struct ContainerConfigurator {
    static var services: DependencyResolver {
        let container = DependencyContainer()
        
        container.apply(Service() as ServiceProtocol)
        container.apply(ServiceTwo(), label: .two)
        
        return container
    }
    
    static var assemblies: DependencyResolver {
        let container = DependencyContainer()
        
        container.apply(MainAssembly())
        container.apply(AuthorizationAssembly())
        container.apply(RegistrationAssembly())
        container.apply(OnboardingAssembly())
        container.apply(SettingsAssembly())
        
        return container
    }
    
    static var appearance: DependencyResolver {
        let container = DependencyContainer()
        
        container.apply(Color.red, label: .redColor)
        
        return container
    }
}

let resolver = Container.services.resolver
let service = resolver.resolve(Service.self, scope: .unowned)
service.run()

class ViewModel {

    @Dependency(.services, scope: .strong) var config: AppConfigServiceProtocol
    
    //...
    
    func setup() {
        let token = config.obtain(for: .token)
        //...
    }
    
}

@Dependency(.services) var service: ServiceProtocol // .weak scope is used by default

container.apply(Color.red, label: .redColor)
container.apply(Color.green, label: .greenColor)
container.apply(Color.orange, label: .orangeColor)

extension DependencyLabel {
    static let redColor = ContainerLabel(value: "redColor")
    static let greenColor = ContainerLabel(value: "greenColor")
    static let orangeColor = ContainerLabel(value: "orangeColor")
}

@Dependency(.appearance, scope: .strong, label: .redColor) var redColor: Color

extension Container {
    static let assembly = Container(ContainerConfigurator.assemblies)
    //...
}

struct ContainerConfigurator {
    
    static var assemblies: DependencyResolver {
        let container = DependencyContainer()
        
        container.apply(MainAssembly())
        container.apply(AuthorizationAssembly())
        container.apply(RegistrationAssembly())
        container.apply(OnboardingAssembly())
        container.apply(SettingsAssembly())
        
        return container
    }
    
    //...
}

protocol Assembly {
    associatedtype C: CoordinatorType
    associatedtype M
    
    func build(coordinator: C) -> M
}

typealias MainModule = Module<MainModuleInput, MainModuleOutput>

struct MainAssembly: Assembly {
    @Dependency(.services, scope: .strong) var config: AppConfigServiceProtocol
    
    func build(coordinator: MainCoordinator) -> MainModule {
        
        // View
        let view = MainViewController()
        
        // Router
        let router = MainRouter(coordinator: coordinator)
        
        // ViewModel
        let viewModel = MainViewModel(router: router, config: config)
        
        // Configure
        viewModel.view = view
        view.output = viewModel
        
        return Module(view: view, input: viewModel, output: viewModel)
    }
}

class MainCoordinator: BaseCoordinator {
    
    // MARK: - Dependencies
    @Dependency(.assemblies) var mainAssembly: MainAssembly
    
    override func start() {
        let module = mainAssembly.build(coordinator: self)
        router.setRootModule(module)
    }
}