docs: public Observable<FluentModelTImpl> commitAsync() {
          if (this.isPostRunMode) {
              return Observable.error(new IllegalStateException("commitAsync() cannot be invoked when 'post run' mode is enabled"));
          }
  
          final ExternalChildResourceCollectionImpl<FluentModelTImpl, FluentModelT, InnerModelT, ParentImplT, ParentT> self = this;
          List<FluentModelTImpl> items = new ArrayList<>();
          for (FluentModelTImpl item : this.childCollection.values()) {
              items.add(item);
          }
  
          final List<Throwable> exceptionsList = Collections.synchronizedList(new ArrayList<Throwable>());
          Observable<FluentModelTImpl> deleteStream = Observable.from(items)
                  .filter(new Func1<FluentModelTImpl, Boolean>() {
                      @Override
                      public Boolean call(FluentModelTImpl childResource) {
                          return childResource.pendingOperation() == ExternalChildResourceImpl.PendingOperation.ToBeRemoved;
                      }
                  }).flatMap(new Func1<FluentModelTImpl, Observable<FluentModelTImpl>>() {
                      @Override
                      public Observable<FluentModelTImpl> call(final FluentModelTImpl childResource) {
                          return childResource.deleteResourceAsync()
                                  .map(new Func1<Void, FluentModelTImpl>() {
                                      @Override
                                      public FluentModelTImpl call(Void response) {
                                          return childResource;
                                      }
                                  }).doOnNext(new Action1<FluentModelTImpl>() {
                                      @Override
                                      public void call(FluentModelTImpl childResource) {
                                          childResource.setPendingOperation(ExternalChildResourceImpl.PendingOperation.None);
                                          self.childCollection.remove(childResource.name());
                                      }
                                  })
                                  .onErrorResumeNext(new Func1<Throwable, Observable<FluentModelTImpl>>() {
                                      @Override
                                      public Observable<FluentModelTImpl> call(Throwable throwable) {
                                          exceptionsList.add(throwable);
                                          return Observable.empty();
                                      }
                                  });
                      }
                  });
  
          Observable<FluentModelTImpl> createStream = Observable.from(items)
                  .filter(new Func1<FluentModelTImpl, Boolean>() {
                      @Override
                      public Boolean call(FluentModelTImpl childResource) {
                          return childResource.pendingOperation() == ExternalChildResourceImpl.PendingOperation.ToBeCreated;
                      }
                  }).flatMap(new Func1<FluentModelTImpl, Observable<FluentModelTImpl>>() {
                      @Override
                      public Observable<FluentModelTImpl> call(final FluentModelTImpl childResource) {
                          return childResource.createResourceAsync()
                                  .map(new Func1<FluentModelT, FluentModelTImpl>() {
                                      @Override
                                      public FluentModelTImpl call(FluentModelT fluentModelT) {
                                          return childResource;
                                      }
                                  })
                                  .doOnNext(new Action1<FluentModelTImpl>() {
                                      @Override
                                      public void call(FluentModelTImpl fluentModelT) {
                                          childResource.setPendingOperation(ExternalChildResourceImpl.PendingOperation.None);
                                      }
                                  })
                                  .onErrorResumeNext(new Func1<Throwable, Observable<? extends FluentModelTImpl>>() {
                                      @Override
                                      public Observable<FluentModelTImpl> call(Throwable throwable) {
                                          self.childCollection.remove(childResource.name());
                                          exceptionsList.add(throwable);
                                          return Observable.empty();
                                      }
                                  });
                      }
                  });
  
          Observable<FluentModelTImpl> updateStream = Observable.from(items)
                  .filter(new Func1<FluentModelTImpl, Boolean>() {
                      @Override
                      public Boolean call(FluentModelTImpl childResource) {
                          return childResource.pendingOperation() == ExternalChildResourceImpl.PendingOperation.ToBeUpdated;
                      }
                  }).flatMap(new Func1<FluentModelTImpl, Observable<FluentModelTImpl>>() {
                      @Override
                      public Observable<FluentModelTImpl> call(final FluentModelTImpl childResource) {
                          return childResource.updateResourceAsync()
                                  .map(new Func1<FluentModelT, FluentModelTImpl>() {
                                      @Override
                                      public FluentModelTImpl call(FluentModelT e) {
                                          return childResource;
                                      }
                                  })
                                  .doOnNext(new Action1<FluentModelTImpl>() {
                                      @Override
                                      public void call(FluentModelTImpl childResource) {
                                          childResource.setPendingOperation(ExternalChildResourceImpl.PendingOperation.None);
                                      }
                                  })
                                  .onErrorResumeNext(new Func1<Throwable, Observable<? extends FluentModelTImpl>>() {
                                      @Override
                                      public Observable<FluentModelTImpl> call(Throwable throwable) {
                                          exceptionsList.add(throwable);
                                          return Observable.empty();
                                      }
                                  });
                      }
                  });
  
          final PublishSubject<FluentModelTImpl> aggregatedErrorStream = PublishSubject.create();
          Observable<FluentModelTImpl> operationsStream = Observable.merge(deleteStream,
                  createStream,
                  updateStream).doOnTerminate(new Action0() {
              @Override
              public void call() {
                  if (clearAfterCommit()) {
                      self.childCollection.clear();
                  }
                  if (exceptionsList.isEmpty()) {
                      aggregatedErrorStream.onCompleted();
                  } else {
                      aggregatedErrorStream.onError(new CompositeException(exceptionsList));
                  }
              }
          });
  
          Observable<FluentModelTImpl> stream = Observable.concat(operationsStream, aggregatedErrorStream);
          return stream;
      }