diff --git a/index.js b/index.js
index 6348b9a..eaef3b4 100644
--- a/index.js
+++ b/index.js
@@ -14,139 +14,141 @@ const gerberFiles = [
   'CAMOutputs/GerberFiles/profile.gbr',
 ];
 
-/**
- * Configures the folders used
- * @param {Object} folderConfig Object with properties tmpDir and imgDir containing paths to temporary and image output folders
- */
-function config(folderConfig) {
-  // Create tmpDir if it does not exist
-  fs.ensureDirSync(folderConfig.tmpDir);
-  // Create imgDir if it does not exist
-  fs.ensureDirSync(folderConfig.imgDir);
-}
+class ImageGenerator {
+  constructor(folderConfig, imgConfig) {
+    // this.folderConfig = folderConfig;
+    this.tmpDir = folderConfig.tmpDir;
+    this.imgDir = folderConfig.imgDir;
+    this.imgConfig = imgConfig;
 
-/**
- * Extracts the passed in zip file
- * @param {string} fileName Name of the file to be extracted
- * @param {string} tmpDir Temporary directory to extract to
- * @returns {Promise} Promise object represents number of files extracted
- */
-function extractArchive(fileName, tmpDir) {
-  // Check archive exists
-  try {
-    if (!fs.existsSync(fileName)) {
-      throw Error('Archive does not exist.');
+    // Ensure that the folders exist
+    try {
+      fs.ensureDirSync(this.tmpDir);
+      fs.ensureDirSync(this.imgDir);
+    } catch (error) {
+      throw new Error(error);
     }
-    if (!fs.existsSync(tmpDir)) {
-      throw Error('Temporary folder does not exist.');
-    }
-  } catch (e) {
-    throw new Error(e);
   }
 
-  const zip = new AdmZip(fileName);
-  zip.extractAllTo(path.join(tmpDir, 'archive'));
-}
-
-/**
- * Take in a directory of layer files and return an array of the layers files
- * @param {string} dir Directory containing layer files
- * @returns {Array} Array of paths to the layers files
- */
-function getLayers(dir) {
-  return new Promise((resolve, reject) => {
-    // Make sure the directory exists
-    if (!fs.existsSync(dir)) {
-      return reject(new Error('Layers folder does not exist.'));
+  /**
+   * Extracts the passed in zip file
+   * @param {string} fileName Name of the file to be extracted
+   * @param {string} tmpDir Temporary directory to extract to
+   * @returns {Promise} Promise object represents number of files extracted
+   */
+  static extractArchive(fileName, tmpDir) {
+    // Check archive exists
+    try {
+      if (!fs.existsSync(fileName)) {
+        throw Error('Archive does not exist.');
+      }
+      if (!fs.existsSync(tmpDir)) {
+        throw Error('Temporary folder does not exist.');
+      }
+    } catch (e) {
+      throw new Error(e);
     }
-    // Check that the required layer files exist in source dir
-    let layersValid = true;
-    gerberFiles.forEach((layer) => {
-      if (!fs.existsSync(path.join(dir, layer))) layersValid = false;
-    });
-    if (!layersValid) return reject(new Error('Layer not found.'));
-    // Construct array of layers that match the supplied filenames array
-    const layers = gerberFiles.map((layerName) => ({
-      filename: layerName,
-      gerber: fs.createReadStream(path.join(dir, layerName)),
-    }));
-    return resolve(layers);
-  });
-}
 
-/**
- * Clean up the archive folder in the specified directory
- * @param {string} dir Path to a directory to clean up
- */
-function cleanupFiles(dir) {
-  try {
-    const folder = path.join(dir, 'archive');
-    fs.emptyDirSync(folder);
-  } catch (err) {
-    throw new Error(err);
-  }
-}
-
-/**
- * Take an archive containing gerber files, config object, temporary dir
- * and output dir and create a PNG image from the gerber in the output dir
- * @param {string} gerber Path to an archive file containing gerber
- * @param {Object} config Object containing sharp settings for resizeWidth, compLevel and density
- * @param {string} tmpDir Temporary directory to extract the archive to
- * @param {string} outputDir Directory to save the image to
- */
-function gerberToImage(gerber, imgConfig, tmpDir, outputDir) {
-  // Create output dir if it doesn't exist
-  try {
-    fs.ensureDirSync(outputDir, 0o644);
-  } catch (e) {
-    throw new Error(e);
+    const zip = new AdmZip(fileName);
+    zip.extractAllTo(path.join(tmpDir, 'archive'));
   }
 
-  // Check temp and output dirs exist
-  try {
-    if (!fs.existsSync(gerber)) {
-      throw Error('Archive does not exist.');
-    }
-    if (!fs.existsSync(tmpDir)) {
-      throw Error('Temporary folder does not exist.');
-    }
-    if (!fs.existsSync(outputDir)) {
-      throw Error('Output folder does not exist.');
-    }
-  } catch (e) {
-    throw new Error(e);
-  }
-
-  // Set filenames
-  const imageName = path.basename(gerber, '.zip');
-  const destFile = `${path.join(outputDir, imageName)}.png`;
-
-  return new Promise((resolve, reject) => {
-    extractArchive(gerber, tmpDir);
-    getLayers(path.join(tmpDir, 'archive'))
-      .then(pcbStackup)
-      .then((stackup) => {
-        sharp(Buffer.from(stackup.top.svg), { density: imgConfig.density })
-          .resize({ width: imgConfig.resizeWidth })
-          .png({ compressionLevel: imgConfig.compLevel })
-          .toFile(destFile);
-      })
-      .then(() => {
-        cleanupFiles(tmpDir);
-        resolve(destFile);
-      })
-      .catch((e) => {
-        cleanupFiles(tmpDir);
-        reject(new Error(e));
+  /**
+   * Take in a directory of layer files and return an array of the layers files
+   * @param {string} dir Directory containing layer files
+   * @returns {Array} Array of paths to the layers files
+   */
+  static getLayers(dir) {
+    return new Promise((resolve, reject) => {
+      // Make sure the directory exists
+      if (!fs.existsSync(dir)) {
+        return reject(new Error('Layers folder does not exist.'));
+      }
+      // Check that the required layer files exist in source dir
+      let layersValid = true;
+      gerberFiles.forEach((layer) => {
+        if (!fs.existsSync(path.join(dir, layer))) layersValid = false;
       });
-  });
+      if (!layersValid) return reject(new Error('Layer not found.'));
+      // Construct array of layers that match the supplied filenames array
+      const layers = gerberFiles.map((layerName) => ({
+        filename: layerName,
+        gerber: fs.createReadStream(path.join(dir, layerName)),
+      }));
+      return resolve(layers);
+    });
+  }
+
+  /**
+   * Clean up the archive folder in the specified directory
+   * @param {string} dir Path to a directory to clean up
+   */
+  static cleanupFiles(dir) {
+    try {
+      const folder = path.join(dir, 'archive');
+      fs.emptyDirSync(folder);
+    } catch (err) {
+      throw new Error(err);
+    }
+  }
+
+  /**
+   * Take an archive containing gerber files, config object, temporary dir
+   * and output dir and create a PNG image from the gerber in the output dir
+   * @param {string} gerber Path to an archive file containing gerber
+   * @returns {Promise.<string>} Promise to return path to image
+   */
+  gerberToImage(gerber) {
+    // Create output dir if it doesn't exist
+    try {
+      fs.ensureDirSync(this.imgDir, 0o644);
+    } catch (e) {
+      throw new Error(e);
+    }
+
+    // Check temp and output dirs exist
+    try {
+      if (!fs.existsSync(gerber)) {
+        throw Error('Archive does not exist.');
+      }
+      if (!fs.existsSync(this.tmpDir)) {
+        throw Error('Temporary folder does not exist.');
+      }
+      if (!fs.existsSync(this.imgDir)) {
+        throw Error('Output folder does not exist.');
+      }
+    } catch (e) {
+      throw new Error(e);
+    }
+
+    // Set filenames
+    const imageName = path.basename(gerber, '.zip');
+    const destFile = `${path.join(this.imgDir, imageName)}.png`;
+
+    return new Promise((resolve, reject) => {
+      ImageGenerator.extractArchive(gerber, this.tmpDir);
+      ImageGenerator.getLayers(path.join(this.tmpDir, 'archive'))
+        .then(pcbStackup)
+        .then((stackup) => {
+          sharp(Buffer.from(stackup.top.svg), {
+            density: this.imgConfig.density,
+          })
+            .resize({ width: this.imgConfig.resizeWidth })
+            .png({ compressionLevel: this.imgConfig.compLevel })
+            .toFile(destFile);
+        })
+        .then(() => {
+          ImageGenerator.cleanupFiles(this.tmpDir);
+          resolve(destFile);
+        })
+        .catch((e) => {
+          ImageGenerator.cleanupFiles(this.tmpDir);
+          reject(new Error(e));
+        });
+    });
+  }
 }
 
 module.exports = {
-  cleanupFiles,
-  getLayers,
-  extractArchive,
-  config,
-  gerberToImage,
+  ImageGenerator,
 };