Connecting a Flux to a Mono

I have a Flux<T> that returns multiple Ts. I need to wait until all the items are emitted from my Flux before continuing on to the Mono. When I was doing similarly with just Monos, I was able to zip them together (using zipWhen()) to achieve this effect. For now I'm setting up and doing the second set of actions in the Flux's doOnComplete(), but it doesn't seem like the best solution.

Note that I'm fairly new to Flux and Mono

    getFlux()
        .doOnComplete(
            () -> {
              // 1a. Retrieve ids from results of the flux
              @NotNull List<String> ids = extractIds(dto.objects); // objects is populated by the Flux
              Mono<?> myOtherMono =
                    getMono1(ids)
                      .zipWhen(
                          // create second mono
                          });
              
              Flux<List<?>> otherFlux =
                  getOtherFlux(ids);
              myOtherMono .and(otherFlux).block();
            })
        .blockLast();

Edited to add more detail:
One of the answers suggested using the then method to essentially turn it into a Mono. I did so, but now it seems to be ignoring the code in the zipWhen. See below:

    getFlux()
        .then()
        .zipWhen( // should continue here when the other mono completes, but it's never getting in here
            (x) -> {
              // 1a. Retrieve ids from results of the flux
              @NotNull List<String> ids = extractIds(dto.objects); // objects is populated by the Flux
              Mono<?> myOtherMono =
                    getMono1(ids)
                      .zipWhen(
                          // create second mono
                          });
              
              Flux<List<?>> otherFlux =
                  getOtherFlux(ids);
              Mono<?> otherFluxAsMono = otherFlux.then()
              return myOtherMono.zipWith(otherFluxAsMono);
            })
        .block();

Sounds like you need then(Mono<V> other) operator of the Flux: https://projectreactor.io/docs/core/release/api/reactor/core/publisher/Flux.html#then-reactor.core.publisher.Mono-

/**
 * Let this {@link Flux} complete then play signals from a provided {@link Mono}.
 * <p>
 * In other words ignore element from this {@link Flux} and transform its completion signal into the
 * emission and completion signal of a provided {@code Mono<V>}. Error signal is
 * replayed in the resulting {@code Mono<V>}.
 *
 * <p>
 * <img class="marble" src="doc-files/marbles/thenWithMonoForFlux.svg" alt="">
 *
 * <p><strong>Discard Support:</strong> This operator discards elements from the source.
 *
 * @param other a {@link Mono} to emit from after termination
 * @param <V> the element type of the supplied Mono
 *
 * @return a new {@link Flux} that wait for source completion then emits from the supplied {@link Mono}
 */
public final <V> Mono<V> then(Mono<V> other) {

If you want a list of all the elements that your flux had, you can use collect
https://projectreactor.io/docs/core/release/api/reactor/core/publisher/Flux.html#collect-java.util.stream.Collector-

example:

.collect(Collectors.toList())

And after that you can use a map or flatmap or any Mono operator.