[out,unique] SamrSamArray *sam,
			[out] uint32_t num_entries);

	[op(0x1b)]
	int SamrOpenAlias([in] policy_handle *domain_handle,
			[in] uint32_t access_mask,
			[in] uint32_t rid,
			[out] policy_handle *alias_handle);

	[op(0x21)]
	int SamrGetMembersInAlias([in] policy_handle *alias_handle,
			[out] LsarSidArray *sids);

	typedef [v1_enum] enum {
		SE_GROUP_MANDATORY          = 0x00000001,

@GwtCompatible(serializable = true, emulated = true)
@SuppressWarnings("serial") // we're overriding default serialization
@ElementTypesAreNonnullByDefault
final class ImmutableEnumMap<K extends Enum<K>, V> extends IteratorBasedImmutableMap<K, V> {
  static <K extends Enum<K>, V> ImmutableMap<K, V> asImmutable(EnumMap<K, V> map) {
    switch (map.size()) {
      case 0:
        return ImmutableMap.of();
      case 1:

from enum import Enum
from typing import Any, Callable, Dict, Iterable, List, Optional, Set, Type, Union

from fastapi._compat import (
    PYDANTIC_V2,
    CoreSchema,
    GetJsonSchemaHandler,
    JsonSchemaValue,
    _model_rebuild,
    with_info_plain_validator_function,
)
from fastapi.logger import logger
from pydantic import AnyUrl, BaseModel, Field
from typing_extensions import Annotated, Literal, TypedDict

### Create an `Enum` class

Import `Enum` and create a sub-class that inherits from `str` and from `Enum`.

By inheriting from `str` the API docs will be able to know that the values must be of type `string` and will be able to render correctly.

    assertThat(Enums.getIfPresent(TestEnum.class, "POODLE")).hasValue(TestEnum.POODLE);

    assertThat(Enums.getIfPresent(TestEnum.class, "CHEETO")).isPresent();
    assertThat(Enums.getIfPresent(TestEnum.class, "HONDA")).isPresent();
    assertThat(Enums.getIfPresent(TestEnum.class, "POODLE")).isPresent();

  }

  // Wrapper of EnumMultiset factory methods, because we need to skip create(Class).
  // create(Enum1.class) is equal to create(Enum2.class) but testEquals() expects otherwise.
  // For the same reason, we need to skip create(Iterable, Class).
  private static class EnumMultisetFactory {
    public static <E extends Enum<E>> EnumMultiset<E> create(Iterable<E> elements) {
      return EnumMultiset.create(elements);
    }
  }

import org.apache.maven.api.annotations.Nonnull;

/**
 * An SPI interface to extend Maven with a new enum value.
 *
 * @param <T> The type of extensible enum to extend
 */
@Experimental
@Consumer
public interface ExtensibleEnumProvider<T extends ExtensibleEnum> extends SpiService {

    /**
     * Registers new values for the T extensible enum.
     *
     * @return a collection of T instances to register
     */
    @Nonnull

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.google.common.hash;


/**
 * An enum that contains all of the known hash functions.
 *
 * @author Kurt Alfred Kluever
 */
enum HashFunctionEnum {
  ADLER32(Hashing.adler32()),
  CRC32(Hashing.crc32()),
  GOOD_FAST_HASH_32(Hashing.goodFastHash(32)),
  GOOD_FAST_HASH_64(Hashing.goodFastHash(64)),

            "ipFamilies": {
              "items": {
                "type": "string",
                "enum": [
                  "IPv4",
                  "IPv6"
                ]
              }
            },
            "ipFamilyPolicy": {
              "type": "string",
              "enum": [
                "",
                "SingleStack",
                "PreferDualStack",

        } else {
          fail(
              rootLocaleFormat(
                  "Feature enum %s contains a class named "
                      + "'Require' but it is not an annotation.",
                  featureEnumClass));
        }
        return;
      }
    }
    fail(
        rootLocaleFormat(
            "Feature enum %s should contain an " + "annotation named 'Require'.",
            featureEnumClass));
  }