docs: def field_type_schema(
      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]]:
      """
      Used by ``field_schema()``, you probably should be using that function.
  
      Take a single ``field`` and generate the schema for its type only, not including additional
      information as title, etc. Also return additional schema definitions, from sub-models.
      """
      definitions = {}
      ref_prefix = ref_prefix or default_prefix
      if field.shape is Shape.LIST:
          f_schema, f_definitions = field_singleton_schema(
              field, by_alias=by_alias, model_name_map=model_name_map, ref_prefix=ref_prefix
          )
          definitions.update(f_definitions)
          return {'type': 'array', 'items': f_schema}, definitions
      elif field.shape is Shape.SET:
          f_schema, f_definitions = field_singleton_schema(
              field, by_alias=by_alias, model_name_map=model_name_map, ref_prefix=ref_prefix
          )
          definitions.update(f_definitions)
          return {'type': 'array', 'uniqueItems': True, 'items': f_schema}, definitions
      elif field.shape is Shape.MAPPING:
          dict_schema: Dict[str, Any] = {'type': 'object'}
          key_field = cast(Field, field.key_field)
          regex = getattr(key_field.type_, 'regex', None)
          f_schema, f_definitions = field_singleton_schema(
              field, by_alias=by_alias, model_name_map=model_name_map, ref_prefix=ref_prefix
          )
          definitions.update(f_definitions)
          if regex:
              # Dict keys have a regex pattern
              # f_schema might be a schema or empty dict, add it either way
              dict_schema['patternProperties'] = {regex.pattern: f_schema}
          elif f_schema:
              # The dict values are not simply Any, so they need a schema
              dict_schema['additionalProperties'] = f_schema
          return dict_schema, definitions
      elif field.shape is Shape.TUPLE:
          sub_schema = []
          sub_fields = cast(List[Field], field.sub_fields)
          for sf in sub_fields:
              sf_schema, sf_definitions = field_type_schema(
                  sf, by_alias=by_alias, model_name_map=model_name_map, ref_prefix=ref_prefix
              )
              definitions.update(sf_definitions)
              sub_schema.append(sf_schema)
          if len(sub_schema) == 1:
              sub_schema = sub_schema[0]  # type: ignore
          return {'type': 'array', 'items': sub_schema}, definitions
      else:
          assert field.shape is Shape.SINGLETON, field.shape
          f_schema, f_definitions = field_singleton_schema(
              field,
              by_alias=by_alias,
              model_name_map=model_name_map,
              schema_overrides=schema_overrides,
              ref_prefix=ref_prefix,
          )
          definitions.update(f_definitions)
          return f_schema, definitions