code: def _extract_definitions(alist, level=None):
      
  
      def _extract_array_defs(source):
          # extract any definitions that are within arrays
          # this occurs recursively
          ret = []
          items = source.get('items')
          if items is not None and 'schema' in items:
              ret += _extract_definitions([items], level+1)
          return ret
  
      # for tracking level of recursion
      if level is None:
          level = 0
  
      defs = list()
      if alist is not None:
          for item in alist:
              schema = item.get("schema")
              if schema is not None:
                  schema_id = schema.get("id")
                  if schema_id is not None:
                      defs.append(schema)
                      ref = {"$ref": "#/definitions/{}".format(schema_id)}
  
                      # only add the reference as a schema if we are in a response or
                      # a parameter i.e. at the top level
                      # directly ref if a definition is used within another definition
                      if level == 0:
                          item['schema'] = ref
                      else:
                          item.update(ref)
                          del item['schema']
  
                  # extract any definitions that are within properties
                  # this occurs recursively
                  properties = schema.get('properties')
                  if properties is not None:
                      defs += _extract_definitions(properties.values(), level+1)
  
                  defs += _extract_array_defs(schema)
  
              defs += _extract_array_defs(item)
  
      return defs
docs: Since we couldn't be bothered to register models elsewhere
      our definitions need to be extracted from the parameters.
      We require an 'id' field for the schema to be correctly
      added to the definitions list.