docs: def resolve_existing_path(path, expected=None, ask_to_resolve=True, expected_classes=None, allow_mult=False,
                            describe=True, all_mult=False, allow_empty_string=True, visibility="either"):
      '''
      :param expected: one of the following: "folder", "entity", or None to indicate
                       whether the expected path is a folder, a data object, or either
      :type expected: string or None
      :param ask_to_resolve: Whether picking may be necessary (if true, a list is returned; if false, only one result is returned)
      :type ask_to_resolve: boolean
      :param expected_classes: A list of expected classes the entity is allowed
                               to belong to if it is an ID (e.g. "record",
                               "file", "job"); if None, then entity_name may be
                               any data object class
      :type expected_classes: list or None
      :param allow_mult: Whether to allow the user to select multiple results from the same path
      :type allow_mult: boolean
      :param describe: Input hash to describe call for the results, or True if no describe input
                       is to be provided
      :type describe: dict or True
      :param all_mult: Whether to return all matching results without prompting (only applicable if allow_mult == True)
      :type all_mult: boolean
      :returns: A LIST of results when ask_to_resolve is False or allow_mult is True
      :raises: :exc:`ResolutionError` if the request path was invalid, or a single result was requested and input is not a TTY
      :param allow_empty_string: If false, a ResolutionError will be raised if *path* is an empty string. Use this when resolving the empty string could result in unexpected behavior.
      :type allow_empty_string: boolean
      :param visibility: The visibility expected ("either", "hidden", or "visible")
      :type visibility: string
  
      Returns either a list of results or a single result (depending on
      how many is expected; if only one, then an interactive picking of
      a choice will be initiated if input is a tty, or else throw an error).
  
      TODO: Always treats the path as a glob pattern.
  
      Output is of the form {"id": id, "describe": describe hash} a list
      of those
  
      TODO: Callers should specify exactly what fields they want, and then
      hopefully we can avoid having a default set of fields that may be very
      expensive
  
      NOTE: if expected_classes is provided and conflicts with the class
      of the hash ID, it will return None for all fields.
      '''
      project, folderpath, entity_name = resolve_path(path, expected=expected, allow_empty_string=allow_empty_string)
      must_resolve, project, folderpath, entity_name = _check_resolution_needed(path,
                                                                                project,
                                                                                folderpath,
                                                                                entity_name,
                                                                                expected_classes=expected_classes,
                                                                                describe=describe,
                                                                                enclose_in_list=(not ask_to_resolve or
                                                                                                 allow_mult))
  
      if must_resolve:
          results = _resolve_global_entity(project, folderpath, entity_name, describe=describe, visibility=visibility)
          if len(results) == 0:
              # Could not resolve entity, so it is probably a folder
              folder = _resolve_folder(project, folderpath, entity_name)
              return project, folder, None
          else:
              validated_results = _validate_resolution_output_length(path,
                                                                     entity_name,
                                                                     results,
                                                                     allow_mult=allow_mult,
                                                                     all_mult=all_mult,
                                                                     ask_to_resolve=ask_to_resolve)
              if is_job_id(project):
                  return None, None, validated_results
              return project, None, validated_results
      return project, folderpath, entity_name