docs: def field_singleton_schema(  # noqa: C901 (ignore complexity)
      field: Field,
      *,
      by_alias: bool,
      model_name_map: Dict[Type['main.BaseModel'], str],
      schema_overrides: bool = False,
      ref_prefix: Optional[str] = None,
  ) -> Tuple[Dict[str, Any], Dict[str, Any]]:
      """
      This function is indirectly used by ``field_schema()``, you should probably be using that function.
  
      Take a single Pydantic ``Field``, and return its schema and any additional definitions from sub-models.
      """
  
      ref_prefix = ref_prefix or default_prefix
      definitions: Dict[str, Any] = {}
      if field.sub_fields:
          return field_singleton_sub_fields_schema(
              field.sub_fields,
              by_alias=by_alias,
              model_name_map=model_name_map,
              schema_overrides=schema_overrides,
              ref_prefix=ref_prefix,
          )
      if field.type_ is Any:
          return {}, definitions  # no restrictions
      if is_callable_type(field.type_):
          raise SkipField(f'Callable {field.name} was excluded from schema since JSON schema has no equivalent type.')
      f_schema: Dict[str, Any] = {}
      if issubclass(field.type_, Enum):
          f_schema.update({'enum': [item.value for item in field.type_]})  # type: ignore
          # Don't return immediately, to allow adding specific types
      for field_name, schema_name in validation_attribute_to_schema_keyword.items():
          field_value = getattr(field.type_, field_name, None)
          if field_value is not None:
              if field_name == 'regex':
                  field_value = field_value.pattern
              f_schema[schema_name] = field_value
      for type_, t_schema in field_class_to_schema_enum_enabled:
          if issubclass(field.type_, type_):
              f_schema.update(t_schema)
              break
      # Return schema, with or without enum definitions
      if f_schema:
          return f_schema, definitions
      for type_, t_schema in field_class_to_schema_enum_disabled:
          if issubclass(field.type_, type_):
              return t_schema, definitions
      # Handle dataclass-based models
      field_type = field.type_
      if lenient_issubclass(getattr(field_type, '__pydantic_model__', None), main.BaseModel):
          field_type = cast(Type['dataclasses.DataclassType'], field_type)
          field_type = field_type.__pydantic_model__
      if issubclass(field_type, main.BaseModel):
          sub_schema, sub_definitions = model_process_schema(
              field_type, by_alias=by_alias, model_name_map=model_name_map, ref_prefix=ref_prefix
          )
          definitions.update(sub_definitions)
          if not schema_overrides:
              model_name = model_name_map[field_type]
              definitions[model_name] = sub_schema
              return {'$ref': f'{ref_prefix}{model_name}'}, definitions
          else:
              return sub_schema, definitions
      raise ValueError(f'Value not declarable with JSON Schema, field: {field}')