docs: def check_return_types(self, method):
          '''Return types must be correct, their codes must match actual use.'''
          mn = method.__name__
          retanno = method.__annotations__.get('return', None)
          # Take a look at the syntax
          if not retanno:
              return ['Missing return types for method "{}"'.format(mn)]
          if not isinstance(retanno, (list, tuple)):
              msg = 'Return annotation for method "{}" not tuple nor list'
              return [msg.format(mn)]
          if (any(map(lambda t: not isinstance(t, (list, tuple)), retanno)) or
                  any(map(lambda t: not (2 <= len(t) <= 3), retanno))):
              msg = ('Return values series for "{}" should be composed of '
                     '2 or 3-items tuples (code, msg, type).')
              return [msg.format(mn)]
          errors = []
          # Take a look at the codes
          declared = set([t[0] for t in retanno])
          actual = set(int(s)
                       for s in HTTP_STATUSES_REGEX.findall(method.source))
          if declared != actual:
              if declared.issubset(actual):
                  msg = 'Method {} returns undeclared codes: {}.'
                  errors.append(msg.format(mn, actual - declared))
              elif actual.issubset(declared):
                  msg = 'Method {} declares codes {} that are never used.'
                  errors.append(msg.format(mn, declared - actual))
              else:
                  msg = 'Declared {} and Used {} codes mismatch.'
                  errors.append(msg.format(declared, actual))
          # Take a look at the types
          ret_with_types = filter(lambda t: len(t) == 3, retanno)
          msg = 'Method {} return type for code {} must be class (not instance).'
          msg_mod = 'Method {} return type for code {} must subclass from Model.'
          for code, _, type_ in ret_with_types:
              try:
                  if Model not in type_.__bases__:
                      errors.append(msg_mod.format(mn, code))
              except AttributeError:
                  errors.append(msg.format(mn, code))
          return errors