public final class HashMultiset<E extends @Nullable Object> extends AbstractMapBasedMultiset<E> {

  /** Creates a new, empty {@code HashMultiset} using the default initial capacity. */
  public static <E extends @Nullable Object> HashMultiset<E> create() {
    return create(ObjectCountHashMap.DEFAULT_SIZE);
  }

  /**
   * Creates a new, empty {@code HashMultiset} with the specified expected number of distinct
   * elements.
   *

     */
    ExternalModuleDependency create(CharSequence dependencyNotation);

    /**
     * Create an {@link ExternalModuleDependency} from a series of strings.
     *
     * @param group the group (optional)
     * @param name the name
     * @param version the version (optional)
     * @return the new dependency
     */
    ExternalModuleDependency create(@Nullable String group, String name, @Nullable String version);

				}
				if _, err := client.CoreV1().ConfigMaps(cm.ObjectMeta.Namespace).Create(ctx, cm, metav1.CreateOptions{}); err != nil {
					lastError = errors.Wrap(err, "unable to create ConfigMap")
					return false, nil
				}
			}
			return true, nil
		})
	if err == nil {
		return nil
	}
	return lastError
}

import org.gradle.api.provider.MapProperty
import org.gradle.api.provider.Property
import org.gradle.api.provider.SetProperty


/**
 * Creates a simple immutable [Named] object of the given type and name.
 *
 * @param T The type of object to create
 * @param name The name of the created object
 * @return the created named object
 *
 * @see [ObjectFactory.named]
 */

     */
    @Nonnull
    default ArtifactCoordinate create(@Nonnull Session session, @Nonnull String coordinateString) {
        return create(ArtifactCoordinateFactoryRequest.build(session, coordinateString));
    }

    @Nonnull
    default ArtifactCoordinate create(
            @Nonnull Session session, String groupId, String artifactId, String version, String extension) {

    extends AbstractMapBasedMultiset<E> {

  /** Creates a new, empty {@code LinkedHashMultiset} using the default initial capacity. */
  public static <E extends @Nullable Object> LinkedHashMultiset<E> create() {
    return create(ObjectCountHashMap.DEFAULT_SIZE);
  }

  /**
   * Creates a new, empty {@code LinkedHashMultiset} with the specified expected number of distinct
   * elements.
   *

  }

  @Override
  public T create(Object... elements) {
    UnhashableObject[] array = createArray(elements.length);
    int i = 0;
    for (Object e : elements) {
      array[i++] = (UnhashableObject) e;
    }
    return create(array);
  }

  /**
   * Creates a new collection containing the given elements; implement this method instead of {@link
   * #create(Object...)}.
   */

import javax.annotation.Nullable;
import java.io.File;

/**
 * <p>Creates dummy instances of {@link org.gradle.api.Project} which you can use in testing custom task and plugin
 * implementations.</p>
 *
 * <p>To create a project instance:</p>
 *
 * <ol>
 *
 * <li>Create a {@code ProjectBuilder} instance by calling {@link #builder()}.</li>
 *
 * <li>Optionally, configure the builder.</li>

  verbs: ["get", "list", "watch", "update", "create", "patch"]
- apiGroups: ["networking.gke.io"]
  resources: ["servicenetworkendpointgroups","gcpingressparams"]
  verbs: ["get", "list", "watch", "update", "create", "patch"]
# GLBC creates and updates `networking.k8s.io/IngressClass`
- apiGroups: ["networking.k8s.io"]
  resources: ["ingressclasses"]
  verbs: ["get", "list", "watch", "update", "create", "patch"]
# GLBC uses leases for leader election

     *
     * <p>Note: this should be used to create _only_ global scoped instances.
     */
    <K, V> CrossBuildInMemoryCache<K, V> newCache();

    /**
     * Creates a new cache instance. Keys and values are always referenced using strong references.
     *