docs: private Supplier<Availability> findAvailabilityIndicator(String[] commandKeys, Object bean, Method method) {
  		ShellMethodAvailability explicit = method.getAnnotation(ShellMethodAvailability.class);
  		final Method indicator;
  		if (explicit != null) {
  			Assert.isTrue(explicit.value().length == 1, "When set on a @" +
  					ShellMethod.class.getSimpleName() + " method, the value of the @"
  					+ ShellMethodAvailability.class.getSimpleName() +
  					" should be a single element, the name of a method that returns "
  					+ Availability.class.getSimpleName() +
  					". Found " + Arrays.asList(explicit.value()) + " for " + method);
  			indicator = ReflectionUtils.findMethod(bean.getClass(), explicit.value()[0]);
  		} // Try "<method>Availability"
  		else {
  			Method implicit = ReflectionUtils.findMethod(bean.getClass(), method.getName() + "Availability");
  			if (implicit != null) {
  				indicator = implicit;
  			} else {
  				Map<Method, Collection<String>> candidates = new HashMap<>();
  				ReflectionUtils.doWithMethods(bean.getClass(), candidate -> {
  					List<String> matchKeys = new ArrayList<>(Arrays.asList(candidate.getAnnotation(ShellMethodAvailability.class).value()));
  					if (matchKeys.contains("*")) {
  						Assert.isTrue(matchKeys.size() == 1, "When using '*' as a wildcard for " +
  								ShellMethodAvailability.class.getSimpleName() + ", this can be the only value. Found " +
  								matchKeys + " on method " + candidate);
  						candidates.put(candidate, matchKeys);
  					} else {
  						matchKeys.retainAll(Arrays.asList(commandKeys));
  						if (!matchKeys.isEmpty()) {
  							candidates.put(candidate, matchKeys);
  						}
  					}
  				}, m -> m.getAnnotation(ShellMethodAvailability.class) != null && m.getAnnotation(ShellMethod.class) == null);
  
  				// Make sure wildcard approach has less precedence than explicit name
  				Set<Method> notUsingWildcard = candidates.entrySet().stream()
  						.filter(e -> !e.getValue().contains("*"))
  						.map(Map.Entry::getKey)
  						.collect(Collectors.toSet());
  
  				Assert.isTrue(notUsingWildcard.size() <= 1,
  						"Found several @" + ShellMethodAvailability.class.getSimpleName() +
  								" annotated methods that could apply for " + method + ". Offending candidates are "
  								+ notUsingWildcard);
  
  				if (notUsingWildcard.size() == 1) {
  					indicator = notUsingWildcard.iterator().next();
  				} // Wildcard was available
  				else if (candidates.size() == 1) {
  					indicator = candidates.keySet().iterator().next();
  				} else {
  					indicator = null;
  				}
  			}
  		}
  
  		if (indicator != null) {
  			Assert.isTrue(indicator.getReturnType().equals(Availability.class),
  					"Method " + indicator + " should return " + Availability.class.getSimpleName());
  			Assert.isTrue(indicator.getParameterCount() == 0, "Method " + indicator + " should be a no-arg method");
  			ReflectionUtils.makeAccessible(indicator);
  			return () -> (Availability) ReflectionUtils.invokeMethod(indicator, bean);
  		}
  		else {
  			return null;
  		}
  	}