SayHelloViewModel.swift

final class SayHelloViewModel: ViewModelType {
    let input: Input
    let output: Output

    struct Input {
        let name: AnyObserver<String>
        let validate: AnyObserver<Void>
    }

    struct Output {
        let greeting: Driver<String>
    }

    private let nameSubject = ReplaySubject<String>.create(bufferSize: 1)
    private let validateSubject = PublishSubject<Void>()

    init() {
        let greeting = validateSubject
            .withLatestFrom(nameSubject)
            .map { name in
                return "Hello \(name)!"
            }
            .asDriver(onErrorJustReturn: ":-(")

        self.output = Output(greeting: greeting)
        self.input = Input(name: nameSubject.asObserver(), validate: validateSubject.asObserver())
    }
}

I had to abandon the BaseViewModel class, as well as the parameters and functions of the SomeViewModel class that should be used in closures. And also the init function turns out to be rather cumbersome because nothing can be taken out of it into other functions without self.

I got something like this, but I'm not sure if this approach is suitable for all cases:

final class SomeViewModel: ViewModelType /* <-- protocol */ {
    
    let input: Input
    let output: Output

    struct Input {
        // nothing intresting
    }

    struct Output {
        let sections: Driver<[SectionModel<CellViewModel>]>
        let activityTracker: ActivityTracker
        let errors: ErrorTracker<Errors>
    }

    private let disposeBag = DisposeBag()

    override init() {
        let activityTracker = ActivityTracker() // <-- I can't declare it as a class parameter because I use it in closure where I can't use `self`
        let errorTracker = ErrorTracker<Errors>() // <-- the same
        input = Input()
        
        // prepare setCommand and selectCommand
        let sections = Observable.of(setCommand, selectCommand)
            .merge()
            .flatMap({ command -> Observable<Event<TableViewEditingCommand>> in
                switch command {
                case .setItems:
                    return Observable.just(command)

                case .selectItem(let indexPath):
                    return someUseCase.sendSomeRequest()
                        .trackActivity(activityTracker) // <-- `self` can't be used here
                        .map { command }
                        .asObservable()
                }
            })
            // some other stuff

        output = Output(sections: sections,
                        activityTracker: activityTracker,
                        errors: errorTracker)
    }
    
}

Maybe you have ideas how to improve it and avoid cumbersome?