fs.readFile('src/compiler/diagnosticInformationMap.generated.ts', 'utf-8', (err, data) => {
    let errorRegexp = /\s(\w+): \{ code/g;
    let errorNames: string[] = [];
    let errMatch: string[];
    while (errMatch = errorRegexp.exec(data)) {
        errorNames.push(errMatch[1]);
    }

    let allSrc: string = '';
    glob('./src/**/*.ts', {}, (err, files) => {
        console.log('Reading ' + files.length + ' source files');
        for (let file of files) {
            if (file.indexOf('diagnosticInformationMap.generated.ts') > 0) {
                continue;
            }

            let src = fs.readFileSync(file, 'utf-8');
            allSrc = allSrc + src;
        }

        console.log('Consumed ' + allSrc.length + ' characters of source');

        let count = 0;
        console.log('== List of errors not used in source ==');
        for (let errName of errorNames) {
            if (allSrc.indexOf(errName) < 0) {
                console.log(errName);
                count++;
            }
        }
        console.log(count + ' of ' + errorNames.length + ' errors are not used in source');
    });
});

export function build(srcDir: string, options = {}) {
    //const _dtsCreator = require('typed-css-modules');
    let dtsCreator = new DtsCreator({
        srcDir
    });

    return glob(srcDir + globSuffix, {}, (error: any, files: string[]) => files.forEach(writeFile(dtsCreator)));
}

 return new Promise<string[]>((resolve, reject) => {
   glob(pattern, { ignore }, (error, matches) => {
     if (error) {
       reject(error)
     } else {
       resolve(matches)
     }
   })
 })

  return new Promise<string[]>((resolve, reject) => {
      glob(globPattern, (err, files: string[]) => {
        if (err) {
          reject(err);
        }

        resolve(files);
      });
    })

 return new Promise((resolve, reject) => {
   glob(pattern, { root: dir, nocase: true }, (error, files) => {
     if (error || (required && (!files || !files.length))) {
       reject(error || `Could not find files matching ${glob} in ${dir}.`);
     } else {
       resolve(files);
     }
   });
 });

 return new Promise((resolve, reject) => {
     glob(pattern, options || {}, (err, matches) => {
         if (err) {
             reject(err);
         } else {
             resolve(matches);
         }
     });
 });

		return new Promise<string[]>((c, e) => {
			glob(task.pattern, task.opts, (err, files: string[]) => {
				if (err) {
					e(err);
				} else {
					c(files);
				}
			});
		});

 return new Promise<string[]>((resolve, reject) => {
   glob(
     pattern,
     globOptions,
     (error, files) => {
       if (error) { reject(error) }
       else { resolve(files) }
     }
   )
 })

    return new Promise<string[]>((resolve, reject) => {
        glob(globFileName, (err, files) => {
            /* istanbul ignore if */
            if (err) {
                reject(err);
                return;
            }

            resolve(files);
        });
    });

  return new Promise((resolve, reject) => {
    glob(
      globPattern,
      { cwd: process.cwd(), ignore: ['**/node_modules/**'] },
      (error: any, files: string[]) => {
        if (error) {
          return reject(error);
        }

        resolve(files);
      }
    );
  });