docs: public static <T> AutoDisposeConverter<T> autoDisposable(final CompletableSource scope) {
      checkNotNull(scope, "scope == null");
      return new AutoDisposeConverter<T>() {
        @Override
        public ParallelFlowableSubscribeProxy<T> apply(final ParallelFlowable<T> upstream) {
          return subscribers ->
              new AutoDisposeParallelFlowable<>(upstream, scope).subscribe(subscribers);
        }
  
        @Override
        public CompletableSubscribeProxy apply(final Completable upstream) {
          return new CompletableSubscribeProxy() {
            @Override
            public Disposable subscribe() {
              return new AutoDisposeCompletable(upstream, scope).subscribe();
            }
  
            @Override
            public Disposable subscribe(Action action) {
              return new AutoDisposeCompletable(upstream, scope).subscribe(action);
            }
  
            @Override
            public Disposable subscribe(Action action, Consumer<? super Throwable> onError) {
              return new AutoDisposeCompletable(upstream, scope).subscribe(action, onError);
            }
  
            @Override
            public void subscribe(CompletableObserver observer) {
              new AutoDisposeCompletable(upstream, scope).subscribe(observer);
            }
  
            @Override
            public <E extends CompletableObserver> E subscribeWith(E observer) {
              return new AutoDisposeCompletable(upstream, scope).subscribeWith(observer);
            }
  
            @Override
            public TestObserver<Void> test() {
              TestObserver<Void> observer = new TestObserver<>();
              subscribe(observer);
              return observer;
            }
  
            @Override
            public TestObserver<Void> test(boolean cancel) {
              TestObserver<Void> observer = new TestObserver<>();
              if (cancel) {
                observer.cancel();
              }
              subscribe(observer);
              return observer;
            }
          };
        }
  
        @Override
        public FlowableSubscribeProxy<T> apply(final Flowable<T> upstream) {
          return new FlowableSubscribeProxy<T>() {
            @Override
            public Disposable subscribe() {
              return new AutoDisposeFlowable<>(upstream, scope).subscribe();
            }
  
            @Override
            public Disposable subscribe(Consumer<? super T> onNext) {
              return new AutoDisposeFlowable<>(upstream, scope).subscribe(onNext);
            }
  
            @Override
            public Disposable subscribe(
                Consumer<? super T> onNext, Consumer<? super Throwable> onError) {
              return new AutoDisposeFlowable<>(upstream, scope).subscribe(onNext, onError);
            }
  
            @Override
            public Disposable subscribe(
                Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete) {
              return new AutoDisposeFlowable<>(upstream, scope)
                  .subscribe(onNext, onError, onComplete);
            }
  
            @Override
            public Disposable subscribe(
                Consumer<? super T> onNext,
                Consumer<? super Throwable> onError,
                Action onComplete,
                Consumer<? super Subscription> onSubscribe) {
              return new AutoDisposeFlowable<>(upstream, scope)
                  .subscribe(onNext, onError, onComplete, onSubscribe);
            }
  
            @Override
            public void subscribe(Subscriber<? super T> observer) {
              new AutoDisposeFlowable<>(upstream, scope).subscribe(observer);
            }
  
            @Override
            public <E extends Subscriber<? super T>> E subscribeWith(E observer) {
              return new AutoDisposeFlowable<>(upstream, scope).subscribeWith(observer);
            }
  
            @Override
            public TestSubscriber<T> test() {
              TestSubscriber<T> ts = new TestSubscriber<>();
              subscribe(ts);
              return ts;
            }
  
            @Override
            public TestSubscriber<T> test(long initialRequest) {
              TestSubscriber<T> ts = new TestSubscriber<>(initialRequest);
              subscribe(ts);
              return ts;
            }
  
            @Override
            public TestSubscriber<T> test(long initialRequest, boolean cancel) {
              TestSubscriber<T> ts = new TestSubscriber<>(initialRequest);
              if (cancel) {
                ts.cancel();
              }
              subscribe(ts);
              return ts;
            }
          };
        }
  
        @Override
        public MaybeSubscribeProxy<T> apply(final Maybe<T> upstream) {
          return new MaybeSubscribeProxy<T>() {
            @Override
            public Disposable subscribe() {
              return new AutoDisposeMaybe<>(upstream, scope).subscribe();
            }
  
            @Override
            public Disposable subscribe(Consumer<? super T> onSuccess) {
              return new AutoDisposeMaybe<>(upstream, scope).subscribe(onSuccess);
            }
  
            @Override
            public Disposable subscribe(
                Consumer<? super T> onSuccess, Consumer<? super Throwable> onError) {
              return new AutoDisposeMaybe<>(upstream, scope).subscribe(onSuccess, onError);
            }
  
            @Override
            public Disposable subscribe(
                Consumer<? super T> onSuccess,
                Consumer<? super Throwable> onError,
                Action onComplete) {
              return new AutoDisposeMaybe<>(upstream, scope)
                  .subscribe(onSuccess, onError, onComplete);
            }
  
            @Override
            public void subscribe(MaybeObserver<? super T> observer) {
              new AutoDisposeMaybe<>(upstream, scope).subscribe(observer);
            }
  
            @Override
            public <E extends MaybeObserver<? super T>> E subscribeWith(E observer) {
              return new AutoDisposeMaybe<>(upstream, scope).subscribeWith(observer);
            }
  
            @Override
            public TestObserver<T> test() {
              TestObserver<T> observer = new TestObserver<>();
              subscribe(observer);
              return observer;
            }
  
            @Override
            public TestObserver<T> test(boolean cancel) {
              TestObserver<T> observer = new TestObserver<>();
              if (cancel) {
                observer.cancel();
              }
              subscribe(observer);
              return observer;
            }
          };
        }
  
        @Override
        public ObservableSubscribeProxy<T> apply(final Observable<T> upstream) {
          return new ObservableSubscribeProxy<T>() {
            @Override
            public Disposable subscribe() {
              return new AutoDisposeObservable<>(upstream, scope).subscribe();
            }
  
            @Override
            public Disposable subscribe(Consumer<? super T> onNext) {
              return new AutoDisposeObservable<>(upstream, scope).subscribe(onNext);
            }
  
            @Override
            public Disposable subscribe(
                Consumer<? super T> onNext, Consumer<? super Throwable> onError) {
              return new AutoDisposeObservable<>(upstream, scope).subscribe(onNext, onError);
            }
  
            @Override
            public Disposable subscribe(
                Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete) {
              return new AutoDisposeObservable<>(upstream, scope)
                  .subscribe(onNext, onError, onComplete);
            }
  
            @Override
            public Disposable subscribe(
                Consumer<? super T> onNext,
                Consumer<? super Throwable> onError,
                Action onComplete,
                Consumer<? super Disposable> onSubscribe) {
              return new AutoDisposeObservable<>(upstream, scope)
                  .subscribe(onNext, onError, onComplete, onSubscribe);
            }
  
            @Override
            public void subscribe(Observer<? super T> observer) {
              new AutoDisposeObservable<>(upstream, scope).subscribe(observer);
            }
  
            @Override
            public <E extends Observer<? super T>> E subscribeWith(E observer) {
              return new AutoDisposeObservable<>(upstream, scope).subscribeWith(observer);
            }
  
            @Override
            public TestObserver<T> test() {
              TestObserver<T> observer = new TestObserver<>();
              subscribe(observer);
              return observer;
            }
  
            @Override
            public TestObserver<T> test(boolean dispose) {
              TestObserver<T> observer = new TestObserver<>();
              if (dispose) {
                observer.dispose();
              }
              subscribe(observer);
              return observer;
            }
          };
        }
  
        @Override
        public SingleSubscribeProxy<T> apply(final Single<T> upstream) {
          return new SingleSubscribeProxy<T>() {
            @Override
            public Disposable subscribe() {
              return new AutoDisposeSingle<>(upstream, scope).subscribe();
            }
  
            @Override
            public Disposable subscribe(Consumer<? super T> onSuccess) {
              return new AutoDisposeSingle<>(upstream, scope).subscribe(onSuccess);
            }
  
            @Override
            public Disposable subscribe(BiConsumer<? super T, ? super Throwable> biConsumer) {
              return new AutoDisposeSingle<>(upstream, scope).subscribe(biConsumer);
            }
  
            @Override
            public Disposable subscribe(
                Consumer<? super T> onSuccess, Consumer<? super Throwable> onError) {
              return new AutoDisposeSingle<>(upstream, scope).subscribe(onSuccess, onError);
            }
  
            @Override
            public void subscribe(SingleObserver<? super T> observer) {
              new AutoDisposeSingle<>(upstream, scope).subscribe(observer);
            }
  
            @Override
            public <E extends SingleObserver<? super T>> E subscribeWith(E observer) {
              return new AutoDisposeSingle<>(upstream, scope).subscribeWith(observer);
            }
  
            @Override
            public TestObserver<T> test() {
              TestObserver<T> observer = new TestObserver<>();
              subscribe(observer);
              return observer;
            }
  
            @Override
            public TestObserver<T> test(boolean dispose) {
              TestObserver<T> observer = new TestObserver<>();
              if (dispose) {
                observer.dispose();
              }
              subscribe(observer);
              return observer;
            }
          };
        }
      };
    }