function parseOwnerInfo(obj: any): OwnerInfo {
  let stackObjs = parseArray(obj, verifyObject);

  if (stackObjs.length < 1) {
    throw new Error(`No stacks found for owner object.`);
  }

  let projects = new Map<string, ProjectInfo>();
  // Get the owner from the first stack
  let owner = verifyObjectProperty(stackObjs[0], 'stackId', parseStackOwner);

  for (let stackObj of stackObjs) {
    let stackName = verifyObjectProperty(stackObj, 'stackId', parseStackName);
    let stackInfo = parseStackInfo(stackObj);

    if (stackInfo !== undefined) {
      let projectName = stackInfo.project;
      let projectInfo = projects.get(projectName);

      if (projectInfo === undefined) {
        let stacks = new Map<string, StackInfo>();
        projects.set(projectName, {stacks});
        projectInfo = projects.get(projectName);
      }

      projectInfo!.stacks.set(stackName, stackInfo);
    }
  }

  return {owner, projects};
}

 constructor (response: any) {
   if (typeof response !== 'object' || Array.isArray(response)) {
     throw new Error('Failed to parse volume metadata.');
   }
   this.resolution = parseFiniteVec(vec3.create(), response['resolution']);
   this.voxelOffset = parseIntVec(vec3.create(), response['voxel_offset']);
   this.size = parseIntVec(vec3.create(), response['size']);
   this.chunkSizes = parseArray(response['chunk_sizes'], x => parseFiniteVec(vec3.create(), x));
   if (this.chunkSizes.length === 0) {
     throw new Error('No chunk sizes specified.');
   }
   let encodingStr = response['encoding'];
   let encoding = serverChunkEncodings.get(encodingStr);
   if (encoding === undefined) {
     throw new Error(`Invalid chunk encoding: ${JSON.stringify(encodingStr)}`);
   }
   this.encoding = encoding;
   if (encoding === VolumeChunkEncoding.COMPRESSED_SEGMENTATION) {
     this.compressedSegmentationBlockSize = parseIntVec(vec3.create(), response['compressed_segmentation_block_size']);
   }
   this.key = response['key'];
   if (typeof this.key !== 'string') {
     throw new Error('No key specified.');
   }
 }

this.scales = verifyObjectProperty(obj, 'scales', x => parseArray(x, y => new ScaleInfo(y)));

 x => parseArray(x, y => parseFixedLengthArray(vec3.create(), y, verifyPositiveInt)));

 scalesObj => parseArray(
     scalesObj,
     scaleObj => parseFixedLengthArray(vec3.create(), scaleObj, verifyFinitePositiveFloat)));

 .then(value => parseArray(value, verifyString));