docs: @Deprecated
      public static GeographyValue CreateStar(
              GeographyPointValue center,
              GeographyPointValue firstVertex,
              int numPointsInStar,
              double ratioOfPointLength, // pass in 1.0 for a polygon with twice the number of vertices, or .1 for a very jagged star
              double sizeOfHole) throws IllegalArgumentException {
          // I don't think a 1 or 2 pointed star is possible.
          if (numPointsInStar < 3) {
              throw new IllegalArgumentException("Star polygons must have 3 or more points.");
          }
  
          if (sizeOfHole < 0 || 1.0 <= sizeOfHole) {
              throw new IllegalArgumentException("Star polygon hole size must be in the range [0.0, 1.0)");
          }
          if (ratioOfPointLength <= 0 || 1.0 < ratioOfPointLength) {
              throw new IllegalArgumentException("Star polygon external/internal radius ration must be in the range (0.0, 1.0]");
          }
          // We will add the nth point at angle n*phi.  We want to
          // add points in a counter clockwise order, so phi must be
          // a positive angle.  We will have twice as many vertices
          // as points.
          double phi = 360.0/(2*numPointsInStar);
          GeographyPointValue innerFirstVertex = firstVertex.scale(center, ratioOfPointLength);
          GeographyPointValue holeFirstVertex = null;
          GeographyPointValue innerHoleFirstVertex = null;
  
          // Calculate hole radii.
          if (sizeOfHole > 0) {
              holeFirstVertex = firstVertex.scale(center, sizeOfHole);
              innerHoleFirstVertex = firstVertex.scale(center, sizeOfHole * ratioOfPointLength);
          }
          // The outer and inner radii go here. We will
          // index into this array using the last bit of
          // an integer loop index.
          GeographyPointValue firstVertices[] = {
                  firstVertex,
                  innerFirstVertex
          };
          // We use the same trick here.
          GeographyPointValue holeFirstVertices[] = {
                  holeFirstVertex,
                  innerHoleFirstVertex
          };
          //
          // We have to add all shells in counter clockwise order, and all
          // holes in clockwise order.  This amounts to rotating the shell
          // generator vector by -phi and the hole generator vector by phi.
          //
          List<GeographyPointValue> outerLoop = new ArrayList<>();
          List<GeographyPointValue> holeLoop = null;
          if (sizeOfHole > 0) {
              holeLoop = new ArrayList<>();
          }
          for (int idx = 0; idx < 2*numPointsInStar; idx += 1) {
              GeographyPointValue vert = null;
              GeographyPointValue holeVert = null;
              // Even vertices are the points.
              // Odd vertices are the valleys, if that's the right
              // term.
              vert = firstVertices[idx % 2];
              holeVert = holeFirstVertices[idx % 2];
              outerLoop.add(vert.rotate(idx*phi, center));
              if (sizeOfHole > 0) {
                  holeLoop.add(holeVert.rotate(-(idx*phi), center));
              }
          }
          outerLoop.add(outerLoop.get(0));
          if (sizeOfHole > 0) {
              holeLoop.add(holeLoop.get(0));
          }
          List<List<GeographyPointValue>> loops = new ArrayList<>();
          loops.add(outerLoop);
          if (sizeOfHole > 0) {
              loops.add(holeLoop);
          }
          return new GeographyValue(loops);
      }