text: import re
  from dataclasses import dataclass
  from typing import Any, Callable, Optional, Pattern, TYPE_CHECKING, Tuple, Union
  
  from apischema.metadata.keys import (
      CONVERSION_METADATA,
      DEFAULT_AS_SET_METADATA,
      FALL_BACK_ON_DEFAULT_METADATA,
      FLATTEN_METADATA,
      INIT_VAR_METADATA,
      NONE_AS_UNDEFINED_METADATA,
      POST_INIT_METADATA,
      PROPERTIES_METADATA,
      REQUIRED_METADATA,
      SKIP_METADATA,
      VALIDATORS_METADATA,
  )
  from apischema.types import AnyType, Metadata, MetadataImplem, MetadataMixin
  
  if TYPE_CHECKING:
      from apischema.conversions.conversions import AnyConversion
      from apischema.validation.validators import Validator
  
  
  def simple_metadata(key: str) -> Metadata:
      return MetadataImplem({key: ...})
  
  
  @dataclass(frozen=True)
  class ConversionMetadata(MetadataMixin):
      key = CONVERSION_METADATA
      deserialization: Optional["AnyConversion"] = None
      serialization: Optional["AnyConversion"] = None
  
  
  conversion = ConversionMetadata
  
  default_as_set = simple_metadata(DEFAULT_AS_SET_METADATA)
  
  fall_back_on_default = simple_metadata(FALL_BACK_ON_DEFAULT_METADATA)
  
  flatten = simple_metadata(FLATTEN_METADATA)
  flattened = flatten
  merged = flatten
  
  
  def init_var(tp: AnyType) -> Metadata:
      return MetadataImplem({INIT_VAR_METADATA: tp})
  
  
  none_as_undefined = simple_metadata(NONE_AS_UNDEFINED_METADATA)
  
  post_init = simple_metadata(POST_INIT_METADATA)
  
  
  class PropertiesMetadata(dict, Metadata):  # type: ignore
      def __init__(self):
          super().__init__({PROPERTIES_METADATA: None})
  
      def __call__(
          self, pattern: Union[str, Pattern, "ellipsis"]  # noqa: F821
      ) -> Metadata:
          if pattern is not ...:
              pattern = re.compile(pattern)
          return MetadataImplem({PROPERTIES_METADATA: pattern})
  
  
  properties = PropertiesMetadata()
  
  required = simple_metadata(REQUIRED_METADATA)
  
  
  @dataclass(frozen=True)
  class SkipMetadata(MetadataMixin):
      key = SKIP_METADATA
      deserialization: bool = False
      serialization: bool = False
      serialization_default: bool = False
      serialization_if: Optional[Callable[[Any], Any]] = None
  
      def __call__(
          self,
          deserialization: bool = False,
          serialization: bool = False,
          serialization_default: bool = False,
          serialization_if: Optional[Callable[[Any], Any]] = None,
      ) -> "SkipMetadata":
          return SkipMetadata(
              deserialization, serialization, serialization_default, serialization_if
          )
  
  
  skip = SkipMetadata(deserialization=True, serialization=True)
  
  
  @dataclass(frozen=True)
  class ValidatorsMetadata(MetadataMixin):
      key = VALIDATORS_METADATA
      validators: Tuple["Validator", ...]
  
  
  def validators(*validator: Callable) -> ValidatorsMetadata:
      from apischema.validation.validators import Validator
  
      return ValidatorsMetadata(tuple(map(Validator, validator)))
  