docs: def create_model(  # noqa: C901 (ignore complexity)
      model_name: str,
      *,
      __config__: Type[BaseConfig] = None,
      __base__: Type[BaseModel] = None,
      __module__: Optional[str] = None,
      __validators__: Dict[str, classmethod] = None,
      **field_definitions: Any,
  ) -> BaseModel:
      """
      Dynamically create a model.
      :param model_name: name of the created model
      :param __config__: config class to use for the new model
      :param __base__: base class for the new model to inherit from
      :param __validators__: a dict of method names and @validator class methods
      :param **field_definitions: fields of the model (or extra fields if a base is supplied) in the format
          `<name>=(<type>, <default default>)` or `<name>=<default value> eg. `foobar=(str, ...)` or `foobar=123`
      """
      if __base__:
          if __config__ is not None:
              raise ConfigError('to avoid confusion __config__ and __base__ cannot be used together')
      else:
          __base__ = BaseModel
  
      fields = {}
      annotations = {}
  
      for f_name, f_def in field_definitions.items():
          if f_name.startswith('_'):
              warnings.warn(f'fields may not start with an underscore, ignoring "{f_name}"', RuntimeWarning)
          if isinstance(f_def, tuple):
              try:
                  f_annotation, f_value = f_def
              except ValueError as e:
                  raise ConfigError(
                      f'field definitions should either be a tuple of (<type>, <default>) or just a '
                      f'default value, unfortunately this means tuples as '
                      f'default values are not allowed'
                  ) from e
          else:
              f_annotation, f_value = None, f_def
  
          if f_annotation:
              annotations[f_name] = f_annotation
          fields[f_name] = f_value
  
      namespace: 'DictStrAny' = {'__annotations__': annotations, '__module__': __module__}
      if __validators__:
          namespace.update(__validators__)
      namespace.update(fields)
      if __config__:
          namespace['Config'] = inherit_config(__config__, BaseConfig)
  
      return type(model_name, (__base__,), namespace)