docs: def check_stops(
      feed: "Feed", *, as_df: bool = False, include_warnings: bool = False
  ) -> List:
      """
      Analog of :func:`check_agency` for ``feed.stops``.
      """
      table = "stops"
      problems = []
  
      # Preliminary checks
      if feed.stops is None:
          problems.append(["error", "Missing table", table, []])
      else:
          f = feed.stops.copy()
          problems = check_for_required_columns(problems, table, f)
      if problems:
          return format_problems(problems, as_df=as_df)
  
      if include_warnings:
          problems = check_for_invalid_columns(problems, table, f)
  
      # Check stop_id
      problems = check_column_id(problems, table, f, "stop_id")
  
      # Check stop_code, stop_desc, zone_id, parent_station
      for column in ["stop_code", "stop_desc", "zone_id", "parent_station"]:
          problems = check_column(
              problems, table, f, column, valid_str, column_required=False
          )
  
      # Check stop_name
      problems = check_column(problems, table, f, "stop_name", valid_str)
  
      # Check stop_lon and stop_lat
      if "location_type" in f.columns:
          requires_location = f["location_type"].isin([0, 1, 2])
      else:
          requires_location = True
      for column, bound in [("stop_lon", 180), ("stop_lat", 90)]:
          v = lambda x: pd.notnull(x) and -bound <= x <= bound
          cond = requires_location & ~f[column].map(v)
          problems = check_table(
              problems,
              table,
              f,
              cond,
              f"{column} out of bounds {[-bound, bound]}",
          )
  
      # Check stop_url
      problems = check_column(
          problems, table, f, "stop_url", valid_url, column_required=False
      )
  
      # Check location_type
      v = lambda x: x in range(5)
      problems = check_column(
          problems, table, f, "location_type", v, column_required=False
      )
  
      # Check stop_timezone
      problems = check_column(
          problems,
          table,
          f,
          "stop_timezone",
          valid_timezone,
          column_required=False,
      )
  
      # Check wheelchair_boarding
      v = lambda x: x in range(3)
      problems = check_column(
          problems, table, f, "wheelchair_boarding", v, column_required=False
      )
  
      # Check further location_type and parent_station
      if "parent_station" in f.columns:
          if "location_type" not in f.columns:
              problems.append(
                  [
                      "error",
                      "parent_station column present but location_type column missing",
                      table,
                      [],
                  ]
              )
          else:
              # Stations must have location type 1
              station_ids = f.loc[
                  f["parent_station"].notnull(), "parent_station"
              ]
              cond = f["stop_id"].isin(station_ids) & (f["location_type"] != 1)
              problems = check_table(
                  problems, table, f, cond, "A station must have location_type 1"
              )
  
              # Stations must not lie in stations
              cond = (f["location_type"] == 1) & f["parent_station"].notnull()
              problems = check_table(
                  problems,
                  table,
                  f,
                  cond,
                  "A station must not lie in another station",
              )
  
              # Entrances (type 2), generic nodes (type 3) and boarding areas (type 4) need to be part of a parent
              cond = (
                  f["location_type"].isin([2, 3, 4])
                  & f["parent_station"].isnull()
              )
              problems = check_table(
                  problems,
                  table,
                  f,
                  cond,
                  "Entrances, nodes, and boarding areas must be part of a parent station",
              )
  
      if include_warnings:
          # Check for stops without trips
          s = feed.stop_times["stop_id"]
          cond = ~feed.stops["stop_id"].isin(s)
          problems = check_table(
              problems, table, f, cond, "Stop has no stop times", "warning"
          )
  
      return format_problems(problems, as_df=as_df)