function WallGeometry(options) {
  options = options ?? Frozen.EMPTY_OBJECT;

  const wallPositions = options.positions;
  const maximumHeights = options.maximumHeights;
  const minimumHeights = options.minimumHeights;

  //>>includeStart('debug', pragmas.debug);
  if (!defined(wallPositions)) {
    throw new DeveloperError("options.positions is required.");
  }
  if (
    defined(maximumHeights) &&
    maximumHeights.length !== wallPositions.length
  ) {
    throw new DeveloperError(
      "options.positions and options.maximumHeights must have the same length.",
    );
  }
  if (
    defined(minimumHeights) &&
    minimumHeights.length !== wallPositions.length
  ) {
    throw new DeveloperError(
      "options.positions and options.minimumHeights must have the same length.",
    );
  }
  //>>includeEnd('debug');

  const vertexFormat = options.vertexFormat ?? VertexFormat.DEFAULT;
  const granularity = options.granularity ?? CesiumMath.RADIANS_PER_DEGREE;
  const ellipsoid = options.ellipsoid ?? Ellipsoid.default;

  this._positions = wallPositions;
  this._minimumHeights = minimumHeights;
  this._maximumHeights = maximumHeights;
  this._vertexFormat = VertexFormat.clone(vertexFormat);
  this._granularity = granularity;
  this._ellipsoid = Ellipsoid.clone(ellipsoid);
  this._workerName = "createWallGeometry";

  let numComponents = 1 + wallPositions.length * Cartesian3.packedLength + 2;
  if (defined(minimumHeights)) {
    numComponents += minimumHeights.length;
  }
  if (defined(maximumHeights)) {
    numComponents += maximumHeights.length;
  }

  /**
   * The number of elements used to pack the object into an array.
   * @type {number}
   */
  this.packedLength =
    numComponents + Ellipsoid.packedLength + VertexFormat.packedLength + 1;
}
A description of a wall, which is similar to a KML line string. A wall is defined by a series of points,
which extrude down to the ground. Optionally, they can extrude downwards to a specified height.

@alias WallGeometry
@constructor

@param {object} options Object with the following properties:
@param {Cartesian3[]} options.positions An array of Cartesian objects, which are the points of the wall.
@param {number} [options.granularity=CesiumMath.RADIANS_PER_DEGREE] The distance, in radians, between each latitude and longitude. Determines the number of positions in the buffer.
@param {number[]} [options.maximumHeights] An array parallel to <code>positions</code> that give the maximum height of the
       wall at <code>positions</code>. If undefined, the height of each position in used.
@param {number[]} [options.minimumHeights] An array parallel to <code>positions</code> that give the minimum height of the
       wall at <code>positions</code>. If undefined, the height at each position is 0.0.
@param {Ellipsoid} [options.ellipsoid=Ellipsoid.default] The ellipsoid for coordinate manipulation
@param {VertexFormat} [options.vertexFormat=VertexFormat.DEFAULT] The vertex attributes to be computed.

@exception {DeveloperError} positions length must be greater than or equal to 2.
@exception {DeveloperError} positions and maximumHeights must have the same length.
@exception {DeveloperError} positions and minimumHeights must have the same length.

@see WallGeometry#createGeometry
@see WallGeometry#fromConstantHeight

@demo {@link https://sandcastle.cesium.com/index.html?src=Wall.html|Cesium Sandcastle Wall Demo}

@example
// create a wall that spans from ground level to 10000 meters
const wall = new Cesium.WallGeometry({
  positions : Cesium.Cartesian3.fromDegreesArrayHeights([
    19.0, 47.0, 10000.0,
    19.0, 48.0, 10000.0,
    20.0, 48.0, 10000.0,
    20.0, 47.0, 10000.0,
    19.0, 47.0, 10000.0
  ])
});
const geometry = Cesium.WallGeometry.createGeometry(wall);