constructor() {
     this.validator = new Validator();
     this.validator.addSchema(signatureDataSchema as JSONSchema, signatureDataSchema.id);
     this.validator.addSchema(tokenSchema as JSONSchema, tokenSchema.id);
     this.validator.addSchema(orderTakerSchema as JSONSchema, orderTakerSchema.id);
     this.validator.addSchema(orderSchema as JSONSchema, orderSchema.id);
 }

export function getValidationErrors(commandKey: string, commandConfig: any, commandSchema: any): string[] {
	const validator = new Validator();
	const result = validator.validate(commandConfig, commandSchema);

	const errors = result.errors.map((err: any) => {
		let message = err.stack;
		message = message.replace(' enum ', ' expected ');
		message = message.replace('instance', `${commandKey} config`);
		return message;
	});

	return errors;
}

	export function validate (element: any, schema: any) {
        let v = new Validator();
        return v.validate(element, schema);
	}

 // In order to validate a complex JS object using jsonschema, we must replace any complex
 // sub-types (e.g BigNumber) with a simpler string representation. Since BigNumber and other
 // complex types implement the `toString` method, we can stringify the object and
 // then parse it. The resultant object can then be checked using jsonschema.
 /**
  * Validate the JS object conforms to a specific JSON schema
  * @param instance JS object in question
  * @param schema Schema to check against
  * @returns The results of the validation
  */
 public validate(instance: any, schema: Schema): ValidatorResult {
     const jsonSchemaCompatibleObject = JSON.parse(JSON.stringify(instance));
     return this._validator.validate(jsonSchemaCompatibleObject, schema);
 }

 /**
  * Instantiates a SchemaValidator instance
  */
 constructor() {
     this._validator = new Validator();
     for (const schema of values(schemas)) {
         this._validator.addSchema(schema, schema.id);
     }
 }

function save(file: string, schema: any, data: any) {
  const result = validator.validate(data, schema);
  if (result.errors.length > 0) {
    throw result.errors;
  }
  const content = JSON.stringify(data, null, 2);
  fs.writeFileSync(file, content, "utf8");
}

export function validateAnalysis(analyzedPackage: Analysis|null|undefined) {
  const result = validator.validate(analyzedPackage, schema);
  if (result.throwError) {
    throw result.throwError;
  }
  if (result.errors.length > 0) {
    throw new ValidationError(result);
  }
  if (!/^1\.\d+\.\d+$/.test(analyzedPackage!.schema_version)) {
    throw new Error(
        `Invalid schema_version in AnalyzedPackage. ` +
        `Expected 1.x.x, got ${analyzedPackage!.schema_version}`);
  }
}

function load(file: string, schema: any) {
  if (!fs.existsSync(file)) {
    return undefined;
  }
  try {
    const data = fs.readFileSync(file, "utf8");
    const obj = JSON.parse(data);
    const result = validator.validate(obj, schema);
    if (result.errors.length === 0) {
      return obj;
    } else {
      console.error(`invalid JSON data found in ${name}`, result.errors);
      return undefined;
    }
  } catch (e) {
    console.error(`failed to load JSON data from ${name}`, e);
    return undefined;
  }
}

 /**
  * Add a schema to the validator. All schemas and sub-schemas must be added to
  * the validator before the `validate` and `isValid` methods can be called with
  * instances of that schema.
  * @param schema The schema to add
  */
 public addSchema(schema: Schema) {
     this._validator.addSchema(schema, schema.id);
 }

 public validate(instance: object, schema: Schema) {
     return this.validator.validate(instance, schema);
 }